SHARE
TWEET

Untitled

a guest Oct 12th, 2017 48 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. struct CMDS {
  2.     const char* name;
  3.     char len;
  4. };
  5.  
  6. struct CMDS comm[] = { {"CONNECT", 7}, {"CONNECT_OK", 10}, {"GET_VER", 7}, {"GET_DATA", 8}, {"GET_FILE", 8}, {"GET_COMMAND", 11}, {"GET_B64", 7}, {"DISCONNECT", 10}, {"VERSION ", 8}, {"B64: ", 5}, {"DISCONNECT_OK", 13} };
  7.  
  8. enum PreviousMess { WRONG, RIGHT };
  9. char dataValid[127] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 };
  10. char b64Valid[127] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, };
  11.  
  12. char CheckDirection(int* state, enum Direction direct);
  13. char CheckState(int* prevState, int* state, enum Direction direct, enum PreviousMess* message, char* str, char** cmd);
  14. void Mistake(messagePtr, statePtr, prevStatePtr);
  15. void True(messagePtr, statePtr, prevStatePtr);
  16. char CheckCMD(char* str, char** cmd);
  17. char CheckVer(char* str);
  18. char CheckB64(char* str);
  19.  
  20. int state = 1;
  21. int prevState = 1;
  22. enum PreviousMess message = WRONG;
  23. char* cmd[12];
  24. char* prevComm[20];
  25.  
  26. int* statePtr = &state;
  27. int* prevStatePtr = &prevState;
  28. enum PreviousMess* messagePtr = &message;
  29. char** cmdPtr = &cmd;
  30. char** prevCommPtr = &prevComm;
  31.  
  32. enum test_status validate_message( struct Message *msg ) {
  33.  
  34.     // TODO: Implement me
  35.     if (!CheckState(prevStatePtr, statePtr, msg->direction, messagePtr, cmdPtr, prevCommPtr))
  36.         return MESSAGE_INVALID;
  37.     return MESSAGE_VALID;    
  38. }
  39.  
  40. char CheckDirection(int* state, enum Direction direct) {
  41.     switch (*state) {
  42.     case 1: {
  43.         if (direct != A_TO_B)
  44.             return 0;
  45.         break;
  46.     }
  47.     case 2: {
  48.         if (direct != B_TO_A)
  49.             return 0;
  50.         break;
  51.     }
  52.     case 3: {
  53.         if (direct != A_TO_B)
  54.             return 0;
  55.         break;
  56.     }
  57.     case 4: {
  58.         if (direct != B_TO_A)
  59.             return 0;
  60.         break;
  61.     }
  62.     case 5: {
  63.         if (direct != B_TO_A)
  64.             return 0;
  65.         break;
  66.     }
  67.     case 6: {
  68.         if (direct != B_TO_A)
  69.             return 0;
  70.         break;
  71.     }
  72.     case 7: {
  73.         if (direct != B_TO_A)
  74.             return 0;
  75.         break;
  76.     }
  77.     default: return 0;
  78.     }
  79.  
  80.     return 1;
  81. }
  82.  
  83. void Mistake(messagePtr, statePtr, prevStatePtr) {
  84.     messagePtr = WRONG;
  85.     prevStatePtr = statePtr;
  86.     statePtr = 1;
  87. }
  88.  
  89. void True(messagePtr, statePtr, prevStatePtr) {
  90.     messagePtr = RIGHT;
  91.     prevStatePtr = statePtr;
  92. }
  93.  
  94. char CheckVer(char* str) {
  95.     int len = strlen(str);
  96.  
  97.     if (len <= 8)
  98.         return 0;
  99.  
  100.     char* tmp = malloc(10);
  101.  
  102.     strncpy_s(tmp, 0, str, 7);
  103.     if (strcmp(tmp, comm[8].name)) {
  104.         free(tmp);
  105.         return 0;
  106.     }
  107.  
  108.     tmp = "";
  109.  
  110.     strncpy_s(tmp, 8, str, len - 1);
  111.  
  112.     int k = atoi(tmp);
  113.  
  114.     if (k <= 0) {
  115.         free(tmp);
  116.         return 0;
  117.     }
  118.  
  119.     return 1;
  120. }
  121.  
  122. char CheckB64(char* str) {
  123.     int len = strlen(str);
  124.  
  125.     if (len <= 5)
  126.         return 0;
  127.  
  128.     char* tmp = malloc(10);
  129.  
  130.     strncpy_s(tmp, 0, str, 4);
  131.     if (strcmp(tmp, comm[9].name)) {
  132.         free(tmp);
  133.         return 0;
  134.     }
  135.  
  136.     free(tmp);
  137.  
  138.     for (int i = 5; i < len - 2; i++) {
  139.         if (!b64Valid[str[i]])
  140.             return 0;
  141.     }
  142.  
  143.     if ((str[len - 2] != '=' && !b64Valid[str[len - 2]])
  144.         || (str[len - 1] != '=' && !b64Valid[str[len - 1]]))
  145.         return 0;
  146.  
  147.     return 1;
  148. }
  149.  
  150. char CheckCMD(char* str, char** cmd) {
  151.     int len = strlen(str);
  152.     int len2 = strlen(*cmd);
  153.  
  154.     if (len <= len2 * 2 + 2)
  155.         return 0;
  156.  
  157.     char* tmp = malloc(len2 + 2);
  158.  
  159.     strncpy_s(tmp, 0, str, len2);
  160.  
  161.     if (strcmp(tmp, *cmd) != 0) {
  162.         free(tmp);
  163.         return 0;
  164.     }
  165.  
  166.     if (str[len2] != ' ' || str[len - len2 - 1] != ' ') {
  167.         free(tmp);
  168.         return 0;
  169.     }
  170.  
  171.     for (int i = len2 + 1; i < len - len2 - 1; i++) {
  172.         if ((!dataValid[str[i]])) {
  173.             free(tmp);
  174.             return 0;
  175.         }
  176.     }
  177.  
  178.     strncpy_s(tmp, len - len2, str, len - 1);
  179.  
  180.     if (strcmp(tmp, *cmd) != 0) {
  181.         free(tmp);
  182.         return 0;
  183.     }
  184.  
  185.     free(tmp);
  186.    
  187.     return 1;
  188. }
  189.  
  190. char CheckState(int* prevState, int* state, enum Direction direct, enum PreviousMess* message, char* str, char** cmd) {
  191.     if (!CheckDirection(statePtr, direct)) {
  192.         Mistake(messagePtr, statePtr, prevStatePtr);
  193.         return 0;
  194.     }
  195.  
  196.     switch (*state) {
  197.  
  198.     case 1: {
  199.         if (strcmp(str, comm[0].name) != 0 || *message != WRONG && prevState != 7) {
  200.             Mistake(messagePtr, statePtr, prevStatePtr);
  201.             return 0;
  202.         }
  203.  
  204.         True(messagePtr, statePtr, prevStatePtr);
  205.         *state = 2;
  206.  
  207.         return 1;
  208.     }
  209.  
  210.     case 2: {
  211.         if (strcmp(str, comm[1].name) != 0 || *message != WRONG && prevState != 1) {
  212.             Mistake(messagePtr, statePtr, prevStatePtr);
  213.             return 0;
  214.         }
  215.  
  216.         True(messagePtr, statePtr, prevStatePtr);
  217.         *state = 3;
  218.  
  219.         return 1;
  220.     }
  221.  
  222.     case 3: {
  223.         if (*message == WRONG || (prevState != 4
  224.             && prevState != 5 && prevState != 7)) {
  225.             Mistake(messagePtr, statePtr, prevStatePtr);
  226.             return 0;
  227.         }
  228.  
  229.         if (strcmp(str, comm[2].name) == 0)
  230.             *state = 4;
  231.         else  if (strcmp(str, comm[3].name) == 0
  232.             || strcmp(str, comm[4].name) == 0 || strcmp(str, comm[5].name) == 0)
  233.             *state = 5;
  234.         else if (strcmp(str, comm[6].name) == 0)
  235.             *state = 6;
  236.         else if (strcmp(str, comm[7].name) == 0)
  237.             *state = 7;
  238.         else {
  239.             Mistake(messagePtr, statePtr, prevStatePtr);
  240.             return 0;
  241.         }
  242.         True(messagePtr, statePtr, prevStatePtr);
  243.         *state = 3;
  244.  
  245.         return 1;
  246.     }
  247.  
  248.  
  249.     case 4: {
  250.         if (strcmp(*cmd, comm[8].name) != 0 || *message == WRONG
  251.             || !CheckVer(str) || prevState != 3) {
  252.             Mistake(messagePtr, statePtr, prevStatePtr);
  253.             return 0;
  254.         }
  255.  
  256.         True(messagePtr, statePtr, prevStatePtr);
  257.         *state = 3;
  258.  
  259.         return 1;
  260.     }
  261.  
  262.     case 5: {
  263.         if ( *message == WRONG || !CheckCMD(str, prevCommPtr)
  264.             || prevState != 3) {
  265.             Mistake(messagePtr, statePtr, prevStatePtr);
  266.             return 0;
  267.         }
  268.  
  269.         True(messagePtr, statePtr, prevStatePtr);
  270.         *state = 3;
  271.  
  272.         return 1;
  273.     }
  274.  
  275.     case 6: {
  276.         if (strcmp(*cmd, comm[9].name) != 0 || !CheckB64(str)
  277.             || *message == WRONG || prevState != 3) {
  278.             Mistake(messagePtr, statePtr, prevStatePtr);
  279.             return 0;
  280.         }
  281.  
  282.         True(messagePtr, statePtr, prevStatePtr);
  283.         *state = 3;
  284.  
  285.         return 1;
  286.     }
  287.  
  288.     case 7: {
  289.         if (strcmp(str, comm[10].name) != 0 || *message == WRONG || prevState != 3) {
  290.             Mistake(messagePtr, statePtr, prevStatePtr);
  291.             return 0;
  292.         }
  293.  
  294.         True(messagePtr, statePtr, prevStatePtr);
  295.         *state = 1;
  296.  
  297.         return 1;
  298.     }
  299.  
  300.     default: return 0;
  301.     }
  302. }
RAW Paste Data
Top