CPU_INT32U  HTTP_Dict_KeyGet (const  HTTP_DICT    *p_dict_tbl,
                                     CPU_INT32U    dict_size,
                              const  CPU_CHAR     *p_str_cmp,
                                     CPU_BOOLEAN   case_sensitive,
                                     CPU_INT32U    str_len)
{
    CPU_INT32U   nbr_entry;
    CPU_INT32U   ix;
    CPU_INT32U   len;
    CPU_INT16S   cmp;
    HTTP_DICT   *p_srch;


    nbr_entry =  dict_size / sizeof(HTTP_DICT);
    p_srch    = (HTTP_DICT *)p_dict_tbl;
    for (ix = 0; ix < nbr_entry; ix++) {
        len = DEF_MIN(str_len, p_srch->StrLen);
        if (case_sensitive == DEF_YES) {
            cmp = Str_Cmp_N(p_str_cmp, p_srch->StrPtr, len);
            if (cmp == 0) {
                return (p_srch->Key);
            }
        } else {
            cmp = Str_CmpIgnoreCase_N(p_str_cmp, p_srch->StrPtr, len);
            if (cmp == 0) {
                return (p_srch->Key);
            }
        }

        p_srch++;
    }

    return (HTTP_DICT_KEY_INVALID);
}
/*
*********************************************************************************************************
* Store new CIK in flash
*********************************************************************************************************
*/
void Exosite_SetCIK(CPU_CHAR * pCIK)
{
    rdk_meta *meta_info = (rdk_meta *)RDK_META_LOCATION;

    if (0 != Str_Cmp_N((CPU_CHAR*)meta_info->cik, pCIK, CIK_LENGTH))
    {
        rdk_meta_write((unsigned char *)pCIK, CIK_LENGTH, (unsigned char *)meta_info->cik);
    }
    Str_Copy_N(CIK, pCIK, CIK_LENGTH);
}
static void init_flash_content(void)
{
    rdk_meta *meta_info;

    rdk_meta_init();

    meta_info = (rdk_meta *)RDK_META_LOCATION;

    if (0 != Str_Cmp_N((CPU_CHAR*)meta_info->mark, EXOMARK, Str_Len(EXOMARK)))
    {
        rdk_meta_defaults();
    }

    // Get local copy as it can be set temporarily
    Str_Copy_N(CIK, (CPU_CHAR*)meta_info->cik, CIK_LENGTH);

    // Convert stored copy to something usable
    IP   =  meta_info->server[0] * 16777216
          + meta_info->server[1] * 65536
          + meta_info->server[2] * 256
          + meta_info->server[3] * 1;
    PORT =  meta_info->server[4] * 256
          + meta_info->server[5] * 1;
}
void update_m2ip(void)
{
    NET_SOCK_ID  sock;
    CPU_SIZE_T   len, rxlen, IPLEN = 23; // 23 => 3*6+5 => "nnn,nnn,nnn,nnn,nnn,nnn"
    CPU_CHAR    *p;
    CPU_CHAR     rx[RX_SIZE], ip[23];

    sock = socket_open();

    if (-1 == sock)
    {
        return;
    }

    if (
        18 != socket_send(sock, "GET /ip HTTP/1.1\r\n", 18) ||
        22 != socket_send(sock, "Host: m2.exosite.com\r\n", 22) ||
        35 != socket_send(sock, "Accept: text/plain; charset=utf-8\r\n", 35) ||
        2  != socket_send(sock, "\r\n", 2)
    )
    {
        socket_close(sock);
        return;
    }

    // @HTTP/x.x NNN@
    rxlen = socket_recv(sock, rx, 12);

    if (12 == rxlen && '2' == rx[9] && '0' == rx[10] && '0' == rx[11])
    {
        CPU_CHAR crlf = 0;
        CPU_CHAR iplen = 0;

        do
        {
            rxlen = socket_recv(sock, rx, RX_SIZE);
            len = rxlen;
            p = rx;

            // Find 4 consecutive \r or \n - should be: \r\n\r\n
            while (0 < len && 4 > crlf)
            {
                if ('\r' == *p || '\n' == *p)
                {
                    ++crlf;
                }
                else
                {
                    crlf = 0;
                }
                ++p;
                --len;
            }

            // The body is "nnn,nnn,nnn,nnn,nnn,nnn"
            if (0 < len && 4 == crlf && IPLEN > iplen)
            {
                // TODO, be more robust - match Content-Length header value to IPLEN
                CPU_CHAR need, part;
                need = IPLEN - iplen;
                part = need < len ? need : len;
                Str_Copy_N(ip + iplen, p, part);
                iplen += part;
            }
        } while (RX_SIZE == rxlen);

        if (0 < iplen && IPLEN >= iplen)
        {
            CPU_CHAR server_ip[6];
            CPU_CHAR i;

            p = ip;

            for (i = 0; i < 6 || iplen > 0; i++)
            {
                if (*p >= '0' && *p <= '9')
                {
                    server_ip[i] = *p++ - '0';
                    if (0 == --iplen) break;
                }
                if (*p >= '0' && *p <= '9')
                {
                    server_ip[i] *= 10;
                    server_ip[i] += *p++ - '0';
                    if (0 == --iplen) break;
                }
                if (*p >= '0' && *p <= '9')
                {
                    server_ip[i] *= 10;
                    server_ip[i] += *p++ - '0';
                    --iplen;
                }
                if (iplen > 0)
                {
                    if (5 == i || ',' != *p++)
                    {
                        break;
                    }
                    --iplen;
                }
            }

            if (6 == i)
            {
                rdk_meta *meta_info = (rdk_meta *)RDK_META_LOCATION;

                if (0 != Str_Cmp_N((CPU_CHAR*)meta_info->server, server_ip, 6))
                {
                    rdk_meta_write((unsigned char *)server_ip, 6, (unsigned char *)meta_info->server);

                    // Convert stored copy to something usable
                    IP   =  server_ip[0] * 16777216
                          + server_ip[1] * 65536
                          + server_ip[2] * 256
                          + server_ip[3] * 1;
                    PORT =  server_ip[4] * 256
                          + server_ip[5] * 1;
                }
            }
        }
    }

    socket_close(sock);
    return;
}