Esempio n. 1
0
void CommandLine::ParseFlagOrSetting(std::string argument)
{
	argument.erase(0, 1);
	if (argument.empty())
		return;
	if (IsSetting(argument))
		ParseSetting(argument);
	else
		flags.insert(argument);
}
void MainLoop(int& socket_fd)
{
    NetworkInfo network_info;
    network_info.m_socket_fd = socket_fd;
    if (g_request_status)
    {
        network_info.SetBuffer("STATUS",6);
        network_info.m_available_bytes = network_info.m_remaining_bytes = 6;
        if (!StartSendBuffer(network_info) || 0!=network_info.m_remaining_bytes)
            return;

        network_info.SetBuffer(g_network_buffer,NETWORK_BUFFER_LENGTH);
        if (!StartRecvBuffer(network_info))
            return;

        while (0<network_info.LeftToParse())
        {
            std::string str(network_info.const_buf(), network_info.m_available_bytes);
            network_info.m_parsed_pos = network_info.m_available_bytes;
            fprintf(stdout, "%s", str.c_str());

            if (!ContinueRecvBuffer(network_info))
                return;
        }
    }
    else
    {
        network_info.SetBuffer("NEW",3);
        network_info.m_available_bytes = network_info.m_remaining_bytes = 3;
        if (!StartSendBuffer(network_info) || 0!=network_info.m_remaining_bytes)
            return;

        network_info.SetBuffer(g_network_buffer,NETWORK_BUFFER_LENGTH);
        if (!StartRecvBuffer(network_info) ||
                !ParseWordlist(network_info) || 0<network_info.m_remaining_bytes)
        {
            return;
        }

        if (!StartRecvBuffer(network_info) ||
                !ParseEncryptedText(network_info) || 0<network_info.m_remaining_bytes)
        {
            return;
        }

        while (true)
        {
            network_info.SetBuffer(g_network_buffer,NETWORK_BUFFER_LENGTH);
            if (!StartRecvBuffer(network_info) ||
                    !ParseSetting(network_info) || 0<network_info.m_remaining_bytes)
            {
                break;
            }

            close(socket_fd);
#ifdef DEBUG
            fprintf(stderr, "Closed socket %d\n", socket_fd);
#endif
            socket_fd = -1;

            if (g_done)
            {
                break;
            }

#if 1
            FindBestICScores();

            uint32_t best_optimized_ngram_score=0;
            KeySetting best_ring_setting(g_ring_turnover_positions, g_reflector_ring_settings->m_rings);
            KeySetting best_key_setting(g_ring_turnover_positions, g_reflector_ring_settings->m_rings);
            Plugboard best_plugboard;

            size_t i;
            for (i=0; i<IC_RESULTS_SIZE; i++)
            {
                const uint8_t* ring_settings = g_ic_results[i].m_ring_setting->GetSettings();

                KeySetting tmp_key_setting(g_ring_turnover_positions, g_reflector_ring_settings->m_rings);
                tmp_key_setting = *g_ic_results[i].m_key_setting;

                PrecalcPlugPaths(ring_settings, tmp_key_setting);

                //Initialize plugboard
                Plugboard plugboard;
                plugboard.Initialize();

                uint32_t local_ngram_score = 0;
                while (OptimizeScore(plugboard, g_decrypt_buffer, local_ngram_score));

                if (local_ngram_score > best_optimized_ngram_score)
                {
                    best_optimized_ngram_score = local_ngram_score;
                    best_ring_setting.InitializeStartPosition(*g_ic_results[i].m_ring_setting);
                    best_key_setting = *g_ic_results[i].m_key_setting;
                    best_plugboard = plugboard;
                }
            }
#else
            //Calculate
            KeySetting best_ring_setting(g_ring_turnover_positions, g_reflector_ring_settings->m_rings);
            KeySetting best_key_setting(g_ring_turnover_positions, g_reflector_ring_settings->m_rings);
            Plugboard best_plugboard;
            uint32_t best_optimized_ngram_score = 0;
            Calculate(best_ring_setting, best_key_setting, best_plugboard, best_optimized_ngram_score);
#endif
            //Create socket, send result, loop and read next packet info
            socket_fd = CreateSocket(g_hostname, g_port);
            if (-1 == socket_fd)
            {
                fprintf(stderr, "Connecting to server failed\n");
                return;
            }
#ifdef DEBUG
            fprintf(stderr, "Created socket %d\n", socket_fd);
#endif

            std::string plugboard_str;
            best_plugboard.ToString(plugboard_str, false);

            std::string decrypted_text_str;
            Decrypt(best_ring_setting.GetSettings(), best_key_setting, best_plugboard, g_decrypt_buffer);
            DecryptedString(decrypted_text_str, g_decrypt_buffer);

            sprintf(network_info.buf(), "DONE %d %d %d %s ", g_reflector_ring_settings->ToInt(),
                    best_optimized_ngram_score, best_key_setting.ToInt(best_ring_setting), plugboard_str.c_str());
            network_info.m_available_bytes = strlen(network_info.const_buf());
            network_info.m_remaining_bytes = network_info.m_available_bytes+decrypted_text_str.length();
            if (!StartSendBuffer(network_info))
            {
                return;
            }

            network_info.SetBuffer(decrypted_text_str.c_str(), decrypted_text_str.length());
            network_info.m_available_bytes = decrypted_text_str.length();
            if (!ContinueSendBuffer(network_info) || 0!=network_info.m_remaining_bytes)
            {
                return;
            }
        }
    }
}