Changeset 399 for azure_iot_hub


Ignore:
Timestamp:
Jun 5, 2019, 2:23:55 PM (4 years ago)
Author:
coas-nagasima
Message:

更新

Location:
azure_iot_hub/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • azure_iot_hub/trunk/app_iothub_client/src/client.c

    r396 r399  
    218218                                printf("failure to set option \"MinimumPollingTime\"\r\n");
    219219                        }
     220
     221                        bool traceOn = 1;
     222                        if (IoTHubClient_LL_SetOption(iotHubClientHandle, OPTION_LOG_TRACE, &traceOn) != IOTHUB_CLIENT_OK)
     223                        {
     224                                printf("failure to set option \"log trace on\"\r\n");
     225                        }
    220226#endif
    221227#ifdef SET_TRUSTED_CERT_IN_SAMPLES
     
    241247                                do
    242248                                {
    243                                         //(void)printf("iterator: [%d], callbackCounter: [%d]. \r\n", iterator, callbackCounter);
    244 
    245                                         if (iterator < MESSAGE_COUNT && (iterator <= callbackCounter))
     249                                        if ((iterator < MESSAGE_COUNT) && (iterator <= callbackCounter))
    246250                                        {
    247251                                                temperature = minTemperature + (rand() % 10);
     
    265269                                                        }
    266270
    267                                                         (void)IoTHubMessage_SetContentTypeSystemProperty(messages[iterator].messageHandle, "application/json");
    268                                                         (void)IoTHubMessage_SetContentEncodingSystemProperty(messages[iterator].messageHandle, "utf-8");
     271                                                        if (proto == 0) {
     272                                                                (void)IoTHubMessage_SetContentTypeSystemProperty(messages[iterator].messageHandle, "application/json");
     273                                                                (void)IoTHubMessage_SetContentEncodingSystemProperty(messages[iterator].messageHandle, "utf-8");
     274                                                        }
    269275
    270276                                                        if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messages[iterator].messageHandle, SendConfirmationCallback, &messages[iterator]) != IOTHUB_CLIENT_OK)
     
    277283                                                        }
    278284                                                }
     285                                                iterator++;
    279286                                        }
    280287
    281288                                        IoTHubClient_LL_DoWork(iotHubClientHandle);
    282289                                        ThreadAPI_Sleep(1);
    283 
    284                                         iterator++;
    285290
    286291                                        if (callbackCounter >= MESSAGE_COUNT)
  • azure_iot_hub/trunk/azure_iothub/umqtt/inc/azure_umqtt_c/mqtt_codec.h

    r389 r399  
    2828MOCKABLE_FUNCTION(, void, mqtt_codec_destroy, MQTTCODEC_HANDLE, handle);
    2929
     30MOCKABLE_FUNCTION(, void, mqtt_codec_reset, MQTTCODEC_HANDLE, handle);
    3031MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_connect, const MQTT_CLIENT_OPTIONS*, mqttOptions, STRING_HANDLE, trace_log);
    3132MOCKABLE_FUNCTION(, BUFFER_HANDLE, mqtt_codec_disconnect);
  • azure_iot_hub/trunk/azure_iothub/umqtt/src/mqtt_client.c

    r389 r399  
    113113static STRING_HANDLE construct_trace_log_handle(MQTT_CLIENT* mqtt_client)
    114114{
     115#ifndef NO_LOGGING
    115116    STRING_HANDLE trace_log;
    116117    if (mqtt_client->logTrace)
     
    123124    }
    124125    return trace_log;
     126#else
     127    return NULL;
     128#endif
    125129}
    126130
     
    445449        if (mqtt_codec_bytesReceived(mqtt_client->codec_handle, buffer, size) != 0)
    446450        {
     451            mqtt_codec_reset(mqtt_client->codec_handle);
    447452            set_error_callback(mqtt_client, MQTT_CLIENT_PARSE_ERROR);
    448453        }
     
    12151220                else
    12161221                {
     1222#ifndef NO_LOGGING
    12171223                    if (mqtt_client->logTrace)
    12181224                    {
     
    12211227                        STRING_delete(trace_log);
    12221228                    }
     1229#endif
    12231230                    result = 0;
    12241231                }
     
    12801287                        BUFFER_delete(pingPacket);
    12811288                        (void)tickcounter_get_current_ms(mqtt_client->packetTickCntr, &mqtt_client->timeSincePing);
    1282 
     1289#ifndef NO_LOGGING
    12831290                        if (mqtt_client->logTrace)
    12841291                        {
     
    12871294                            STRING_delete(trace_log);
    12881295                        }
     1296#endif
    12891297                    }
    12901298                }
  • azure_iot_hub/trunk/azure_iothub/umqtt/src/mqtt_codec.c

    r389 r399  
    3838#define UNSUBSCRIBE_FIXED_HEADER_FLAG       0x2
    3939
    40 #define MAX_SEND_SIZE                       0xFFFFFF7F
     40#define MAX_SEND_SIZE                       0xFFFFFF7F // 268435455
     41
     42// This captures the maximum packet size for 3 digits.
     43// If it's above this value then we bail out of the loop
     44#define MAX_3_DIGIT_PACKET_SIZE             2097152
    4145
    4246#define CODEC_STATE_VALUES      \
     
    409413        size_t willTopicLen = 0;
    410414        size_t spaceLen = 0;
     415        size_t currLen = 0;
     416        size_t totalLen = 0;
    411417
    412418        if (mqttOptions->clientId != NULL)
     
    436442        }
    437443
    438         size_t currLen = BUFFER_length(ctrlPacket);
    439         size_t totalLen = clientLen + usernameLen + passwordLen + willMessageLen + willTopicLen + spaceLen;
     444        currLen = BUFFER_length(ctrlPacket);
     445        totalLen = clientLen + usernameLen + passwordLen + willMessageLen + willTopicLen + spaceLen;
    440446
    441447        // Validate the Username & Password
     
    507513                    {
    508514                        (void)STRING_sprintf(connect_payload_trace, " | PWD: XXXX");
     515                        //(void)STRING_sprintf(connect_payload_trace, " | PWD: %s", mqttOptions->password);
    509516                    }
    510517                }
     
    554561                multiplier *= NEXT_128_CHUNK;
    555562
    556                 if (multiplier > 128 * 128 * 128)
     563                if (multiplier > MAX_3_DIGIT_PACKET_SIZE)
    557564                {
    558565                    result = MU_FAILURE;
     
    561568            } while ((encodeByte & NEXT_128_CHUNK) != 0);
    562569
    563             codecData->codecState = CODEC_STATE_VAR_HEADER;
    564 
    565             // Reset remainLen Index
    566             codecData->remainLenIndex = 0;
    567             memset(codecData->storeRemainLen, 0, 4 * sizeof(uint8_t));
    568 
    569             if (totalLen > 0)
    570             {
    571                 codecData->bufferOffset = 0;
    572                 codecData->headerData = BUFFER_new();
    573                 if (codecData->headerData == NULL)
    574                 {
    575                     /* Codes_SRS_MQTT_CODEC_07_035: [ If any error is encountered then the packet state will be marked as error and mqtt_codec_bytesReceived shall return a non-zero value. ] */
    576                     LogError("Failed BUFFER_new");
    577                     result = MU_FAILURE;
    578                 }
    579                 else
    580                 {
    581                     if (BUFFER_pre_build(codecData->headerData, totalLen) != 0)
     570            if (result != 0 || totalLen > MAX_SEND_SIZE)
     571            {
     572                LogError("Receive buffer too large for MQTT packet");
     573                result = MU_FAILURE;
     574            }
     575            else
     576            {
     577                codecData->codecState = CODEC_STATE_VAR_HEADER;
     578
     579                // Reset remainLen Index
     580                codecData->remainLenIndex = 0;
     581                memset(codecData->storeRemainLen, 0, 4 * sizeof(uint8_t));
     582
     583                if (totalLen > 0)
     584                {
     585                    codecData->bufferOffset = 0;
     586                    codecData->headerData = BUFFER_new();
     587                    if (codecData->headerData == NULL)
    582588                    {
    583589                        /* Codes_SRS_MQTT_CODEC_07_035: [ If any error is encountered then the packet state will be marked as error and mqtt_codec_bytesReceived shall return a non-zero value. ] */
    584                         LogError("Failed BUFFER_pre_build");
     590                        LogError("Failed BUFFER_new");
    585591                        result = MU_FAILURE;
    586592                    }
    587 
     593                    else
     594                    {
     595                        if (BUFFER_pre_build(codecData->headerData, totalLen) != 0)
     596                        {
     597                            /* Codes_SRS_MQTT_CODEC_07_035: [ If any error is encountered then the packet state will be marked as error and mqtt_codec_bytesReceived shall return a non-zero value. ] */
     598                            LogError("Failed BUFFER_pre_build");
     599                            result = MU_FAILURE;
     600                        }
     601
     602                    }
    588603                }
    589604            }
     
    611626}
    612627
     628static void clear_codec_data(MQTTCODEC_INSTANCE* codec_data)
     629{
     630    // Clear the code instance data
     631    codec_data->currPacket = UNKNOWN_TYPE;
     632    codec_data->codecState = CODEC_STATE_FIXED_HEADER;
     633    codec_data->headerFlags = 0;
     634    codec_data->bufferOffset = 0;
     635    codec_data->headerData = NULL;
     636    memset(codec_data->storeRemainLen, 0, 4 * sizeof(uint8_t));
     637    codec_data->remainLenIndex = 0;
     638}
     639
     640void mqtt_codec_reset(MQTTCODEC_HANDLE handle)
     641{
     642    if (handle != NULL)
     643    {
     644        clear_codec_data(handle);
     645    }
     646}
     647
    613648MQTTCODEC_HANDLE mqtt_codec_create(ON_PACKET_COMPLETE_CALLBACK packetComplete, void* callbackCtx)
    614649{
     
    619654    {
    620655        /* Codes_SRS_MQTT_CODEC_07_002: [On success mqtt_codec_create shall return a MQTTCODEC_HANDLE value.] */
    621         result->currPacket = UNKNOWN_TYPE;
    622         result->codecState = CODEC_STATE_FIXED_HEADER;
    623         result->headerFlags = 0;
    624         result->bufferOffset = 0;
     656        clear_codec_data(result);
    625657        result->packetComplete = packetComplete;
    626658        result->callContext = callbackCtx;
    627         result->headerData = NULL;
    628         memset(result->storeRemainLen, 0, 4 * sizeof(uint8_t));
    629         result->remainLenIndex = 0;
    630659    }
    631660    return result;
     
    10861115                        result = MU_FAILURE;
    10871116                    }
    1088                     if (codec_Data->currPacket == PINGRESP_TYPE)
     1117                    else if (codec_Data->currPacket == PINGRESP_TYPE)
    10891118                    {
    10901119                        /* Codes_SRS_MQTT_CODEC_07_034: [Upon a constructing a complete MQTT packet mqtt_codec_bytesReceived shall call the ON_PACKET_COMPLETE_CALLBACK function.] */
  • azure_iot_hub/trunk/ntshell/src/fdtable.c

    r389 r399  
    299299ER shell_get_evts(struct fd_events *evts, TMO tmout)
    300300{
    301         int count = 0;
     301        int count;
    302302        SYSTIM prev, now;
    303303        FLGPTN flgptn;
     
    315315                waitptn = *((FLGPTN *)&evts->readfds) | *((FLGPTN *)&evts->errorfds);
    316316#endif
     317                count = 0;
    317318                for (int fd = 0; fd < fd_table_count; fd++) {
    318319                        fp = &fd_table[fd];
  • azure_iot_hub/trunk/ntshell/src/socket_stub.c

    r389 r399  
    7070
    7171#define SOCKET_TIMEOUT 2000000
     72#define TCP_SOCKET_BUF_SIZE 512
    7273
    7374struct addrinfo {
     
    363364                                return -ENOMEM;
    364365
    365                         socket->buf_size = 512 + 512;
     366                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    366367                        socket->buf = malloc(socket->buf_size);
    367368#ifdef _DEBUG
    368369                        memset(socket->buf, 0, socket->buf_size);
    369370#endif
    370                         T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
     371                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    371372                        ret = tcp_cre_cep(cepid, &ccep);
    372373                        if (ret != E_OK) {
     
    410411                                return -ENOMEM;
    411412
    412                         socket->buf_size = 512 + 512;
     413                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    413414                        socket->buf = malloc(socket->buf_size);
    414415#ifdef _DEBUG
    415416                        memset(socket->buf, 0, socket->buf_size);
    416417#endif
    417                         T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     418                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
    418419                        ret = tcp6_cre_cep(cepid, &ccep);
    419420                        if (ret != E_OK) {
     
    522523                                return -ENOMEM;
    523524
    524                         socket->buf_size = 512 + 512;
     525                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    525526                        socket->buf = malloc(socket->buf_size);
    526527#ifdef _DEBUG
    527528                        memset(socket->buf, 0, socket->buf_size);
    528529#endif
    529                         T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
     530                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    530531                        ret = tcp_cre_cep(cepid, &ccep);
    531532                        if (ret != E_OK) {
     
    560561                                return -ENOMEM;
    561562
    562                         socket->buf_size = 512 + 512;
     563                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    563564                        socket->buf = malloc(socket->buf_size);
    564565#ifdef _DEBUG
    565566                        memset(socket->buf, 0, socket->buf_size);
    566567#endif
    567                         T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     568                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
    568569                        ret = tcp6_cre_cep(cepid, &ccep);
    569570                        if (ret != E_OK) {
     
    629630                                return -ENOMEM;
    630631
    631                         socket->buf_size = 512 + 512;
     632                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    632633                        socket->buf = malloc(socket->buf_size);
    633634#ifdef _DEBUG
    634635                        memset(socket->buf, 0, socket->buf_size);
    635636#endif
    636                         T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
     637                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    637638                        ret = tcp_cre_cep(cepid, &ccep);
    638639                        if (ret != E_OK) {
     
    684685                                return -ENOMEM;
    685686
    686                         socket->buf_size = 512 + 512;
     687                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
    687688                        socket->buf = malloc(socket->buf_size);
    688689#ifdef _DEBUG
    689690                        memset(socket->buf, 0, socket->buf_size);
    690691#endif
    691                         T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     692                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
    692693                        ret = tcp6_cre_cep(cepid, &ccep);
    693694                        if (ret != E_OK) {
Note: See TracChangeset for help on using the changeset viewer.