void ST7920_Lite_Status_Screen::cmd(const uint8_t cmd) {
  if (!current_bits.synced || !current_bits.cmd) {
    current_bits.synced = true;
    current_bits.cmd    = true;
    sync_cmd();
  }
  write_byte(cmd);
}
Пример #2
0
void server_mainloop( SOCKET server_socket ) 
{
    SOCKET sClientSocket;
    
    int iResult,                        // system information with error message
        iSendResult,                    // system information with error message after send function
        command_code;
    MBA_AGENT_RETURN command_result;
    
    CHAR sLogMessage[SZ_MAX_LOG];
    CHAR sRecvbuf[SZ_MAX_CMD << 1];          // receive buffer from client
    CHAR sCommand_line[SZ_MAX_CMD << 1];     // fully command line
                                             // we allocate two times more space for the string manipulation
    // Accept connections
    while( true ) {
        
        g_sClientSocket = server_socket;

        sprintf_s(sLogMessage, SZ_MAX_LOG, "[SYSTEM] Start to get commands...\r\n\r\n");
        write_agent_log(sLogMessage, FALSE);
        
        slen = sizeof(clientaddr);

        // Receive until the peer shuts down the connection
        do {
            
            ZeroMemory(sRecvbuf, sizeof(sRecvbuf));
            
            iResult = ac_read( sRecvbuf, SZ_MAX_CMD );
            
            if (iResult > 0) {
            
                sprintf_s(sLogMessage, SZ_MAX_LOG, "Bytes received: 0x%08x, Received message: %s\r\n", iResult, sRecvbuf);
                write_agent_log(sLogMessage, FALSE);
                
                command_code = identify_command(sRecvbuf);
                
                if (command_code > 0) {
                    ZeroMemory(sCommand_line, sizeof(sCommand_line));
                    memcpy(sCommand_line, &sRecvbuf[5], SZ_MAX_CMD - 5);
                }

                switch (command_code) {
                    
                    case MBA_CMD_EXEC :
                        command_result = execute_cmd(sCommand_line);
                        break;

                    case MBA_CMD_INVO :
                        command_result = invoke_cmd(sCommand_line);
                        break;

                    case MBA_CMD_EXPO :
                        command_result = export_cmd(sCommand_line);
                        break;

                    case MBA_CMD_IMPO :
                        command_result = import_cmd(sCommand_line);
                        break;

                    case MBA_CMD_LOGF :
                        command_result = expolog_cmd();
                        break;
                        
                    case MBA_CMD_SYNC :
                        command_result = sync_cmd();
                        break;

                    case MBA_CMD_UNKNOWN :
                    default:
                        write_agent_log("main - [COMMAND ERROR] Unknown command", TRUE);
                        command_result = AGENT_RET_SUCCESS;    
                        break;
                }
        
                if ( command_result == AGENT_RET_SUCCESS ) {
                
                    // Echo the buffer back to the sender
                    iSendResult = ac_write( MSG_ACK_PREFIX, sizeof(MSG_ACK_PREFIX) );
                    if (iSendResult == SOCKET_ERROR) {
                        write_agent_log("main - Send to server_socket", TRUE);
                        break;
                    }
                            
                    iSendResult = ac_write( sRecvbuf, SZ_MAX_CMD );
                    if (iSendResult == SOCKET_ERROR) {
                        write_agent_log("main - Send to server_socket", TRUE);
                        break;
                    }
                }
                else 
                    iResult = 1;
                        
                sprintf_s(sLogMessage, SZ_MAX_LOG, "Bytes sent: %d\r\n\r\n", iSendResult);
                write_agent_log(sLogMessage, FALSE);
            }
            else if (GetLastError() == 0) {
                write_agent_log("Receive nothing from server_socket", FALSE);
                break;
            }
            else {
                write_agent_log("Receive from server_socket", TRUE);
                break;
            }
        } while (iResult > 0);
        
        // shutdown the connection since we're done
        iResult = shutdown(server_socket, SD_SEND);
        if (iResult != -1 && iResult == SOCKET_ERROR) {
            closesocket(server_socket);
            write_agent_log("Main - shutdown server_socket", TRUE);
        }
        closesocket(server_socket);
        sprintf_s(sLogMessage, SZ_MAX_LOG, "[SYSTEM] Connection closing...\r\n");
        write_agent_log(sLogMessage, FALSE);  
    }
}