1 /*

     2  * Generated by erpcgen 1.11.0 on Wed Mar 27 13:43:44 2024.

     3  *

     4  * AUTOGENERATED - DO NOT EDIT

     5  */

     6 

     7 

     8 #include "erpc_PLCObject_server.hpp"

     9 #if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC

    10 #include <new>

    11 #include "erpc_port.h"

    12 #endif

    13 #include "erpc_manually_constructed.hpp"

    14 

    15 #if 11100 != ERPC_VERSION_NUMBER

    16 #error "The generated shim code version is different to the rest of eRPC code."

    17 #endif

    18 

    19 using namespace erpc;

    20 using namespace std;

    21 using namespace erpcShim;

    22 

    23 #if ERPC_NESTED_CALLS_DETECTION

    24 extern bool nestingDetection;

    25 #endif

    26 

    27 

    28 //! @brief Function to read struct binary_t

    29 static void read_binary_t_struct(erpc::Codec * codec, binary_t * data);

    30 

    31 //! @brief Function to read struct extra_file

    32 static void read_extra_file_struct(erpc::Codec * codec, extra_file * data);

    33 

    34 //! @brief Function to read struct list_extra_file_1_t

    35 static void read_list_extra_file_1_t_struct(erpc::Codec * codec, list_extra_file_1_t * data);

    36 

    37 //! @brief Function to read struct trace_order

    38 static void read_trace_order_struct(erpc::Codec * codec, trace_order * data);

    39 

    40 //! @brief Function to read struct list_trace_order_1_t

    41 static void read_list_trace_order_1_t_struct(erpc::Codec * codec, list_trace_order_1_t * data);

    42 

    43 

    44 // Read struct binary_t function implementation

    45 static void read_binary_t_struct(erpc::Codec * codec, binary_t * data)

    46 {

    47     if(NULL == data)

    48     {

    49         return;

    50     }

    51 

    52     uint8_t * data_local;

    53     codec->readBinary(data->dataLength, &data_local);

    54     if (data->dataLength > 0)

    55     {

    56     data->data = (uint8_t *) erpc_malloc(data->dataLength * sizeof(uint8_t));

    57         if (data->data == NULL)

    58         {

    59             codec->updateStatus(kErpcStatus_MemoryError);

    60         }

    61         else

    62         {

    63             memcpy(data->data, data_local, data->dataLength);

    64         }

    65     }

    66     else

    67     {

    68         data->data = NULL;

    69     }

    70 }

    71 

    72 // Read struct extra_file function implementation

    73 static void read_extra_file_struct(erpc::Codec * codec, extra_file * data)

    74 {

    75     if(NULL == data)

    76     {

    77         return;

    78     }

    79 

    80     {

    81         uint32_t fname_len;

    82         char * fname_local;

    83         codec->readString(fname_len, &fname_local);

    84         data->fname = (char*) erpc_malloc((fname_len + 1) * sizeof(char));

    85         if ((data->fname == NULL) || (fname_local == NULL))

    86         {

    87             codec->updateStatus(kErpcStatus_MemoryError);

    88         }

    89         else

    90         {

    91             memcpy(data->fname, fname_local, fname_len);

    92             (data->fname)[fname_len] = 0;

    93         }

    94     }

    95 

    96     read_binary_t_struct(codec, &(data->blobID));

    97 }

    98 

    99 // Read struct list_extra_file_1_t function implementation

   100 static void read_list_extra_file_1_t_struct(erpc::Codec * codec, list_extra_file_1_t * data)

   101 {

   102     if(NULL == data)

   103     {

   104         return;

   105     }

   106 

   107     codec->startReadList(data->elementsCount);

   108     data->elements = (extra_file *) erpc_malloc(data->elementsCount * sizeof(extra_file));

   109     if ((data->elements == NULL) && (data->elementsCount > 0))

   110     {

   111         codec->updateStatus(kErpcStatus_MemoryError);

   112     }

   113     for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

   114     {

   115         read_extra_file_struct(codec, &(data->elements[listCount]));

   116     }

   117 }

   118 

   119 // Read struct trace_order function implementation

   120 static void read_trace_order_struct(erpc::Codec * codec, trace_order * data)

   121 {

   122     if(NULL == data)

   123     {

   124         return;

   125     }

   126 

   127     codec->read(data->idx);

   128 

   129     read_binary_t_struct(codec, &(data->force));

   130 }

   131 

   132 // Read struct list_trace_order_1_t function implementation

   133 static void read_list_trace_order_1_t_struct(erpc::Codec * codec, list_trace_order_1_t * data)

   134 {

   135     if(NULL == data)

   136     {

   137         return;

   138     }

   139 

   140     codec->startReadList(data->elementsCount);

   141     data->elements = (trace_order *) erpc_malloc(data->elementsCount * sizeof(trace_order));

   142     if ((data->elements == NULL) && (data->elementsCount > 0))

   143     {

   144         codec->updateStatus(kErpcStatus_MemoryError);

   145     }

   146     for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

   147     {

   148         read_trace_order_struct(codec, &(data->elements[listCount]));

   149     }

   150 }

   151 

   152 

   153 //! @brief Function to write struct binary_t

   154 static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data);

   155 

   156 //! @brief Function to write struct log_message

   157 static void write_log_message_struct(erpc::Codec * codec, const log_message * data);

   158 

   159 //! @brief Function to write struct PSKID

   160 static void write_PSKID_struct(erpc::Codec * codec, const PSKID * data);

   161 

   162 //! @brief Function to write struct PLCstatus

   163 static void write_PLCstatus_struct(erpc::Codec * codec, const PLCstatus * data);

   164 

   165 //! @brief Function to write struct trace_sample

   166 static void write_trace_sample_struct(erpc::Codec * codec, const trace_sample * data);

   167 

   168 //! @brief Function to write struct TraceVariables

   169 static void write_TraceVariables_struct(erpc::Codec * codec, const TraceVariables * data);

   170 

   171 //! @brief Function to write struct list_trace_sample_1_t

   172 static void write_list_trace_sample_1_t_struct(erpc::Codec * codec, const list_trace_sample_1_t * data);

   173 

   174 

   175 // Write struct binary_t function implementation

   176 static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data)

   177 {

   178     if(NULL == data)

   179     {

   180         return;

   181     }

   182 

   183     codec->writeBinary(data->dataLength, data->data);

   184 }

   185 

   186 // Write struct log_message function implementation

   187 static void write_log_message_struct(erpc::Codec * codec, const log_message * data)

   188 {

   189     if(NULL == data)

   190     {

   191         return;

   192     }

   193 

   194     {

   195         uint32_t msg_len = strlen((const char*)data->msg);

   196 

   197         codec->writeString(msg_len, (const char*)data->msg);

   198     }

   199 

   200     codec->write(data->tick);

   201 

   202     codec->write(data->sec);

   203 

   204     codec->write(data->nsec);

   205 }

   206 

   207 // Write struct PSKID function implementation

   208 static void write_PSKID_struct(erpc::Codec * codec, const PSKID * data)

   209 {

   210     if(NULL == data)

   211     {

   212         return;

   213     }

   214 

   215     {

   216         uint32_t ID_len = strlen((const char*)data->ID);

   217 

   218         codec->writeString(ID_len, (const char*)data->ID);

   219     }

   220 

   221     {

   222         uint32_t PSK_len = strlen((const char*)data->PSK);

   223 

   224         codec->writeString(PSK_len, (const char*)data->PSK);

   225     }

   226 }

   227 

   228 // Write struct PLCstatus function implementation

   229 static void write_PLCstatus_struct(erpc::Codec * codec, const PLCstatus * data)

   230 {

   231     if(NULL == data)

   232     {

   233         return;

   234     }

   235 

   236     codec->write(static_cast<int32_t>(data->PLCstatus));

   237 

   238     for (uint32_t arrayCount0 = 0U; arrayCount0 < 4U; ++arrayCount0)

   239     {

   240         codec->write(data->logcounts[arrayCount0]);

   241     }

   242 }

   243 

   244 // Write struct trace_sample function implementation

   245 static void write_trace_sample_struct(erpc::Codec * codec, const trace_sample * data)

   246 {

   247     if(NULL == data)

   248     {

   249         return;

   250     }

   251 

   252     codec->write(data->tick);

   253 

   254     write_binary_t_struct(codec, &(data->TraceBuffer));

   255 }

   256 

   257 // Write struct TraceVariables function implementation

   258 static void write_TraceVariables_struct(erpc::Codec * codec, const TraceVariables * data)

   259 {

   260     if(NULL == data)

   261     {

   262         return;

   263     }

   264 

   265     codec->write(static_cast<int32_t>(data->PLCstatus));

   266 

   267     write_list_trace_sample_1_t_struct(codec, &(data->traces));

   268 }

   269 

   270 // Write struct list_trace_sample_1_t function implementation

   271 static void write_list_trace_sample_1_t_struct(erpc::Codec * codec, const list_trace_sample_1_t * data)

   272 {

   273     if(NULL == data)

   274     {

   275         return;

   276     }

   277 

   278     codec->startWriteList(data->elementsCount);

   279     for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

   280     {

   281         write_trace_sample_struct(codec, &(data->elements[listCount]));

   282     }

   283 }

   284 

   285 

   286 //! @brief Function to free space allocated inside struct binary_t

   287 static void free_binary_t_struct(binary_t * data);

   288 

   289 //! @brief Function to free space allocated inside struct log_message

   290 static void free_log_message_struct(log_message * data);

   291 

   292 //! @brief Function to free space allocated inside struct PSKID

   293 static void free_PSKID_struct(PSKID * data);

   294 

   295 //! @brief Function to free space allocated inside struct trace_sample

   296 static void free_trace_sample_struct(trace_sample * data);

   297 

   298 //! @brief Function to free space allocated inside struct TraceVariables

   299 static void free_TraceVariables_struct(TraceVariables * data);

   300 

   301 //! @brief Function to free space allocated inside struct list_trace_sample_1_t

   302 static void free_list_trace_sample_1_t_struct(list_trace_sample_1_t * data);

   303 

   304 //! @brief Function to free space allocated inside struct extra_file

   305 static void free_extra_file_struct(extra_file * data);

   306 

   307 //! @brief Function to free space allocated inside struct list_extra_file_1_t

   308 static void free_list_extra_file_1_t_struct(list_extra_file_1_t * data);

   309 

   310 //! @brief Function to free space allocated inside struct trace_order

   311 static void free_trace_order_struct(trace_order * data);

   312 

   313 //! @brief Function to free space allocated inside struct list_trace_order_1_t

   314 static void free_list_trace_order_1_t_struct(list_trace_order_1_t * data);

   315 

   316 

   317 // Free space allocated inside struct binary_t function implementation

   318 static void free_binary_t_struct(binary_t * data)

   319 {

   320     erpc_free(data->data);

   321 }

   322 

   323 // Free space allocated inside struct log_message function implementation

   324 static void free_log_message_struct(log_message * data)

   325 {

   326     erpc_free(data->msg);

   327 }

   328 

   329 // Free space allocated inside struct PSKID function implementation

   330 static void free_PSKID_struct(PSKID * data)

   331 {

   332     erpc_free(data->ID);

   333 

   334     erpc_free(data->PSK);

   335 }

   336 

   337 // Free space allocated inside struct trace_sample function implementation

   338 static void free_trace_sample_struct(trace_sample * data)

   339 {

   340     free_binary_t_struct(&data->TraceBuffer);

   341 }

   342 

   343 // Free space allocated inside struct TraceVariables function implementation

   344 static void free_TraceVariables_struct(TraceVariables * data)

   345 {

   346     free_list_trace_sample_1_t_struct(&data->traces);

   347 }

   348 

   349 // Free space allocated inside struct list_trace_sample_1_t function implementation

   350 static void free_list_trace_sample_1_t_struct(list_trace_sample_1_t * data)

   351 {

   352     for (uint32_t listCount = 0; listCount < data->elementsCount; ++listCount)

   353     {

   354         free_trace_sample_struct(&data->elements[listCount]);

   355     }

   356 

   357     erpc_free(data->elements);

   358 }

   359 

   360 // Free space allocated inside struct extra_file function implementation

   361 static void free_extra_file_struct(extra_file * data)

   362 {

   363     erpc_free(data->fname);

   364 

   365     free_binary_t_struct(&data->blobID);

   366 }

   367 

   368 // Free space allocated inside struct list_extra_file_1_t function implementation

   369 static void free_list_extra_file_1_t_struct(list_extra_file_1_t * data)

   370 {

   371     for (uint32_t listCount = 0; listCount < data->elementsCount; ++listCount)

   372     {

   373         free_extra_file_struct(&data->elements[listCount]);

   374     }

   375 

   376     erpc_free(data->elements);

   377 }

   378 

   379 // Free space allocated inside struct trace_order function implementation

   380 static void free_trace_order_struct(trace_order * data)

   381 {

   382     free_binary_t_struct(&data->force);

   383 }

   384 

   385 // Free space allocated inside struct list_trace_order_1_t function implementation

   386 static void free_list_trace_order_1_t_struct(list_trace_order_1_t * data)

   387 {

   388     for (uint32_t listCount = 0; listCount < data->elementsCount; ++listCount)

   389     {

   390         free_trace_order_struct(&data->elements[listCount]);

   391     }

   392 

   393     erpc_free(data->elements);

   394 }

   395 

   396 

   397 

   398 BeremizPLCObjectService_service::BeremizPLCObjectService_service(BeremizPLCObjectService_interface *_BeremizPLCObjectService_interface)

   399     : erpc::Service(BeremizPLCObjectService_interface::m_serviceId)

   400     , m_handler(_BeremizPLCObjectService_interface)

   401 {

   402 }

   403 

   404 BeremizPLCObjectService_service::~BeremizPLCObjectService_service()

   405 {

   406 }

   407 

   408 // return service interface handler.

   409 BeremizPLCObjectService_interface* BeremizPLCObjectService_service::getHandler(void)

   410 {

   411     return m_handler;

   412 }

   413 

   414 // Call the correct server shim based on method unique ID.

   415 erpc_status_t BeremizPLCObjectService_service::handleInvocation(uint32_t methodId, uint32_t sequence, Codec * codec, MessageBufferFactory *messageFactory, Transport * transport)

   416 {

   417     erpc_status_t erpcStatus;

   418     switch (methodId)

   419     {

   420         case BeremizPLCObjectService_interface::m_AppendChunkToBlobId:

   421         {

   422             erpcStatus = AppendChunkToBlob_shim(codec, messageFactory, transport, sequence);

   423             break;

   424         }

   425 

   426         case BeremizPLCObjectService_interface::m_GetLogMessageId:

   427         {

   428             erpcStatus = GetLogMessage_shim(codec, messageFactory, transport, sequence);

   429             break;

   430         }

   431 

   432         case BeremizPLCObjectService_interface::m_GetPLCIDId:

   433         {

   434             erpcStatus = GetPLCID_shim(codec, messageFactory, transport, sequence);

   435             break;

   436         }

   437 

   438         case BeremizPLCObjectService_interface::m_GetPLCstatusId:

   439         {

   440             erpcStatus = GetPLCstatus_shim(codec, messageFactory, transport, sequence);

   441             break;

   442         }

   443 

   444         case BeremizPLCObjectService_interface::m_GetTraceVariablesId:

   445         {

   446             erpcStatus = GetTraceVariables_shim(codec, messageFactory, transport, sequence);

   447             break;

   448         }

   449 

   450         case BeremizPLCObjectService_interface::m_MatchMD5Id:

   451         {

   452             erpcStatus = MatchMD5_shim(codec, messageFactory, transport, sequence);

   453             break;

   454         }

   455 

   456         case BeremizPLCObjectService_interface::m_NewPLCId:

   457         {

   458             erpcStatus = NewPLC_shim(codec, messageFactory, transport, sequence);

   459             break;

   460         }

   461 

   462         case BeremizPLCObjectService_interface::m_PurgeBlobsId:

   463         {

   464             erpcStatus = PurgeBlobs_shim(codec, messageFactory, transport, sequence);

   465             break;

   466         }

   467 

   468         case BeremizPLCObjectService_interface::m_RepairPLCId:

   469         {

   470             erpcStatus = RepairPLC_shim(codec, messageFactory, transport, sequence);

   471             break;

   472         }

   473 

   474         case BeremizPLCObjectService_interface::m_ResetLogCountId:

   475         {

   476             erpcStatus = ResetLogCount_shim(codec, messageFactory, transport, sequence);

   477             break;

   478         }

   479 

   480         case BeremizPLCObjectService_interface::m_SeedBlobId:

   481         {

   482             erpcStatus = SeedBlob_shim(codec, messageFactory, transport, sequence);

   483             break;

   484         }

   485 

   486         case BeremizPLCObjectService_interface::m_SetTraceVariablesListId:

   487         {

   488             erpcStatus = SetTraceVariablesList_shim(codec, messageFactory, transport, sequence);

   489             break;

   490         }

   491 

   492         case BeremizPLCObjectService_interface::m_StartPLCId:

   493         {

   494             erpcStatus = StartPLC_shim(codec, messageFactory, transport, sequence);

   495             break;

   496         }

   497 

   498         case BeremizPLCObjectService_interface::m_StopPLCId:

   499         {

   500             erpcStatus = StopPLC_shim(codec, messageFactory, transport, sequence);

   501             break;

   502         }

   503 

   504         default:

   505         {

   506             erpcStatus = kErpcStatus_InvalidArgument;

   507             break;

   508         }

   509     }

   510 

   511     return erpcStatus;

   512 }

   513 

   514 // Server shim for AppendChunkToBlob of BeremizPLCObjectService interface.

   515 erpc_status_t BeremizPLCObjectService_service::AppendChunkToBlob_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   516 {

   517     erpc_status_t err = kErpcStatus_Success;

   518 

   519     binary_t *data = NULL;

   520     data = (binary_t *) erpc_malloc(sizeof(binary_t));

   521     if (data == NULL)

   522     {

   523         codec->updateStatus(kErpcStatus_MemoryError);

   524     }

   525     binary_t *blobID = NULL;

   526     blobID = (binary_t *) erpc_malloc(sizeof(binary_t));

   527     if (blobID == NULL)

   528     {

   529         codec->updateStatus(kErpcStatus_MemoryError);

   530     }

   531     binary_t *newBlobID = NULL;

   532     uint32_t result;

   533 

   534     // startReadMessage() was already called before this shim was invoked.

   535 

   536     read_binary_t_struct(codec, data);

   537 

   538     read_binary_t_struct(codec, blobID);

   539 

   540     newBlobID = (binary_t *) erpc_malloc(sizeof(binary_t));

   541     if (newBlobID == NULL)

   542     {

   543         codec->updateStatus(kErpcStatus_MemoryError);

   544     }

   545 

   546     err = codec->getStatus();

   547     if (err == kErpcStatus_Success)

   548     {

   549         // Invoke the actual served function.

   550 #if ERPC_NESTED_CALLS_DETECTION

   551         nestingDetection = true;

   552 #endif

   553         result = m_handler->AppendChunkToBlob(data, blobID, newBlobID);

   554 #if ERPC_NESTED_CALLS_DETECTION

   555         nestingDetection = false;

   556 #endif

   557 

   558         // preparing MessageBuffer for serializing data

   559         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   560     }

   561 

   562     if (err == kErpcStatus_Success)

   563     {

   564         // preparing codec for serializing data

   565         codec->reset(transport->reserveHeaderSize());

   566 

   567         // Build response message.

   568         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_AppendChunkToBlobId, sequence);

   569 

   570         write_binary_t_struct(codec, newBlobID);

   571 

   572         codec->write(result);

   573 

   574         err = codec->getStatus();

   575     }

   576 

   577     if (data)

   578     {

   579         free_binary_t_struct(data);

   580     }

   581     erpc_free(data);

   582 

   583     if (blobID)

   584     {

   585         free_binary_t_struct(blobID);

   586     }

   587     erpc_free(blobID);

   588 

   589     if (newBlobID)

   590     {

   591         free_binary_t_struct(newBlobID);

   592     }

   593     erpc_free(newBlobID);

   594 

   595     return err;

   596 }

   597 

   598 // Server shim for GetLogMessage of BeremizPLCObjectService interface.

   599 erpc_status_t BeremizPLCObjectService_service::GetLogMessage_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   600 {

   601     erpc_status_t err = kErpcStatus_Success;

   602 

   603     uint8_t level;

   604     uint32_t msgID;

   605     log_message *message = NULL;

   606     uint32_t result;

   607 

   608     // startReadMessage() was already called before this shim was invoked.

   609 

   610     codec->read(level);

   611 

   612     codec->read(msgID);

   613 

   614     message = (log_message *) erpc_malloc(sizeof(log_message));

   615     if (message == NULL)

   616     {

   617         codec->updateStatus(kErpcStatus_MemoryError);

   618     }

   619 

   620     err = codec->getStatus();

   621     if (err == kErpcStatus_Success)

   622     {

   623         // Invoke the actual served function.

   624 #if ERPC_NESTED_CALLS_DETECTION

   625         nestingDetection = true;

   626 #endif

   627         result = m_handler->GetLogMessage(level, msgID, message);

   628 #if ERPC_NESTED_CALLS_DETECTION

   629         nestingDetection = false;

   630 #endif

   631 

   632         // preparing MessageBuffer for serializing data

   633         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   634     }

   635 

   636     if (err == kErpcStatus_Success)

   637     {

   638         // preparing codec for serializing data

   639         codec->reset(transport->reserveHeaderSize());

   640 

   641         // Build response message.

   642         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_GetLogMessageId, sequence);

   643 

   644         write_log_message_struct(codec, message);

   645 

   646         codec->write(result);

   647 

   648         err = codec->getStatus();

   649     }

   650 

   651     if (message)

   652     {

   653         free_log_message_struct(message);

   654     }

   655     erpc_free(message);

   656 

   657     return err;

   658 }

   659 

   660 // Server shim for GetPLCID of BeremizPLCObjectService interface.

   661 erpc_status_t BeremizPLCObjectService_service::GetPLCID_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   662 {

   663     erpc_status_t err = kErpcStatus_Success;

   664 

   665     PSKID *plcID = NULL;

   666     uint32_t result;

   667 

   668     // startReadMessage() was already called before this shim was invoked.

   669 

   670     plcID = (PSKID *) erpc_malloc(sizeof(PSKID));

   671     if (plcID == NULL)

   672     {

   673         codec->updateStatus(kErpcStatus_MemoryError);

   674     }

   675 

   676     err = codec->getStatus();

   677     if (err == kErpcStatus_Success)

   678     {

   679         // Invoke the actual served function.

   680 #if ERPC_NESTED_CALLS_DETECTION

   681         nestingDetection = true;

   682 #endif

   683         result = m_handler->GetPLCID(plcID);

   684 #if ERPC_NESTED_CALLS_DETECTION

   685         nestingDetection = false;

   686 #endif

   687 

   688         // preparing MessageBuffer for serializing data

   689         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   690     }

   691 

   692     if (err == kErpcStatus_Success)

   693     {

   694         // preparing codec for serializing data

   695         codec->reset(transport->reserveHeaderSize());

   696 

   697         // Build response message.

   698         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_GetPLCIDId, sequence);

   699 

   700         write_PSKID_struct(codec, plcID);

   701 

   702         codec->write(result);

   703 

   704         err = codec->getStatus();

   705     }

   706 

   707     if (plcID)

   708     {

   709         free_PSKID_struct(plcID);

   710     }

   711     erpc_free(plcID);

   712 

   713     return err;

   714 }

   715 

   716 // Server shim for GetPLCstatus of BeremizPLCObjectService interface.

   717 erpc_status_t BeremizPLCObjectService_service::GetPLCstatus_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   718 {

   719     erpc_status_t err = kErpcStatus_Success;

   720 

   721     PLCstatus *status = NULL;

   722     uint32_t result;

   723 

   724     // startReadMessage() was already called before this shim was invoked.

   725 

   726     status = (PLCstatus *) erpc_malloc(sizeof(PLCstatus));

   727     if (status == NULL)

   728     {

   729         codec->updateStatus(kErpcStatus_MemoryError);

   730     }

   731 

   732     err = codec->getStatus();

   733     if (err == kErpcStatus_Success)

   734     {

   735         // Invoke the actual served function.

   736 #if ERPC_NESTED_CALLS_DETECTION

   737         nestingDetection = true;

   738 #endif

   739         result = m_handler->GetPLCstatus(status);

   740 #if ERPC_NESTED_CALLS_DETECTION

   741         nestingDetection = false;

   742 #endif

   743 

   744         // preparing MessageBuffer for serializing data

   745         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   746     }

   747 

   748     if (err == kErpcStatus_Success)

   749     {

   750         // preparing codec for serializing data

   751         codec->reset(transport->reserveHeaderSize());

   752 

   753         // Build response message.

   754         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_GetPLCstatusId, sequence);

   755 

   756         write_PLCstatus_struct(codec, status);

   757 

   758         codec->write(result);

   759 

   760         err = codec->getStatus();

   761     }

   762 

   763     erpc_free(status);

   764 

   765     return err;

   766 }

   767 

   768 // Server shim for GetTraceVariables of BeremizPLCObjectService interface.

   769 erpc_status_t BeremizPLCObjectService_service::GetTraceVariables_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   770 {

   771     erpc_status_t err = kErpcStatus_Success;

   772 

   773     uint32_t debugToken;

   774     TraceVariables *traces = NULL;

   775     uint32_t result;

   776 

   777     // startReadMessage() was already called before this shim was invoked.

   778 

   779     codec->read(debugToken);

   780 

   781     traces = (TraceVariables *) erpc_malloc(sizeof(TraceVariables));

   782     if (traces == NULL)

   783     {

   784         codec->updateStatus(kErpcStatus_MemoryError);

   785     }

   786 

   787     err = codec->getStatus();

   788     if (err == kErpcStatus_Success)

   789     {

   790         // Invoke the actual served function.

   791 #if ERPC_NESTED_CALLS_DETECTION

   792         nestingDetection = true;

   793 #endif

   794         result = m_handler->GetTraceVariables(debugToken, traces);

   795 #if ERPC_NESTED_CALLS_DETECTION

   796         nestingDetection = false;

   797 #endif

   798 

   799         // preparing MessageBuffer for serializing data

   800         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   801     }

   802 

   803     if (err == kErpcStatus_Success)

   804     {

   805         // preparing codec for serializing data

   806         codec->reset(transport->reserveHeaderSize());

   807 

   808         // Build response message.

   809         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_GetTraceVariablesId, sequence);

   810 

   811         write_TraceVariables_struct(codec, traces);

   812 

   813         codec->write(result);

   814 

   815         err = codec->getStatus();

   816     }

   817 

   818     if (traces)

   819     {

   820         free_TraceVariables_struct(traces);

   821     }

   822     erpc_free(traces);

   823 

   824     return err;

   825 }

   826 

   827 // Server shim for MatchMD5 of BeremizPLCObjectService interface.

   828 erpc_status_t BeremizPLCObjectService_service::MatchMD5_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   829 {

   830     erpc_status_t err = kErpcStatus_Success;

   831 

   832     char * MD5 = NULL;

   833     bool match;

   834     uint32_t result;

   835 

   836     // startReadMessage() was already called before this shim was invoked.

   837 

   838     {

   839         uint32_t MD5_len;

   840         char * MD5_local;

   841         codec->readString(MD5_len, &MD5_local);

   842         MD5 = (char*) erpc_malloc((MD5_len + 1) * sizeof(char));

   843         if ((MD5 == NULL) || (MD5_local == NULL))

   844         {

   845             codec->updateStatus(kErpcStatus_MemoryError);

   846         }

   847         else

   848         {

   849             memcpy(MD5, MD5_local, MD5_len);

   850             (MD5)[MD5_len] = 0;

   851         }

   852     }

   853 

   854     err = codec->getStatus();

   855     if (err == kErpcStatus_Success)

   856     {

   857         // Invoke the actual served function.

   858 #if ERPC_NESTED_CALLS_DETECTION

   859         nestingDetection = true;

   860 #endif

   861         result = m_handler->MatchMD5(MD5, &match);

   862 #if ERPC_NESTED_CALLS_DETECTION

   863         nestingDetection = false;

   864 #endif

   865 

   866         // preparing MessageBuffer for serializing data

   867         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   868     }

   869 

   870     if (err == kErpcStatus_Success)

   871     {

   872         // preparing codec for serializing data

   873         codec->reset(transport->reserveHeaderSize());

   874 

   875         // Build response message.

   876         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_MatchMD5Id, sequence);

   877 

   878         codec->write(match);

   879 

   880         codec->write(result);

   881 

   882         err = codec->getStatus();

   883     }

   884 

   885     erpc_free(MD5);

   886 

   887     return err;

   888 }

   889 

   890 // Server shim for NewPLC of BeremizPLCObjectService interface.

   891 erpc_status_t BeremizPLCObjectService_service::NewPLC_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   892 {

   893     erpc_status_t err = kErpcStatus_Success;

   894 

   895     char * md5sum = NULL;

   896     binary_t *plcObjectBlobID = NULL;

   897     plcObjectBlobID = (binary_t *) erpc_malloc(sizeof(binary_t));

   898     if (plcObjectBlobID == NULL)

   899     {

   900         codec->updateStatus(kErpcStatus_MemoryError);

   901     }

   902     list_extra_file_1_t *extrafiles = NULL;

   903     extrafiles = (list_extra_file_1_t *) erpc_malloc(sizeof(list_extra_file_1_t));

   904     if (extrafiles == NULL)

   905     {

   906         codec->updateStatus(kErpcStatus_MemoryError);

   907     }

   908     bool success;

   909     uint32_t result;

   910 

   911     // startReadMessage() was already called before this shim was invoked.

   912 

   913     {

   914         uint32_t md5sum_len;

   915         char * md5sum_local;

   916         codec->readString(md5sum_len, &md5sum_local);

   917         md5sum = (char*) erpc_malloc((md5sum_len + 1) * sizeof(char));

   918         if ((md5sum == NULL) || (md5sum_local == NULL))

   919         {

   920             codec->updateStatus(kErpcStatus_MemoryError);

   921         }

   922         else

   923         {

   924             memcpy(md5sum, md5sum_local, md5sum_len);

   925             (md5sum)[md5sum_len] = 0;

   926         }

   927     }

   928 

   929     read_binary_t_struct(codec, plcObjectBlobID);

   930 

   931     read_list_extra_file_1_t_struct(codec, extrafiles);

   932 

   933     err = codec->getStatus();

   934     if (err == kErpcStatus_Success)

   935     {

   936         // Invoke the actual served function.

   937 #if ERPC_NESTED_CALLS_DETECTION

   938         nestingDetection = true;

   939 #endif

   940         result = m_handler->NewPLC(md5sum, plcObjectBlobID, extrafiles, &success);

   941 #if ERPC_NESTED_CALLS_DETECTION

   942         nestingDetection = false;

   943 #endif

   944 

   945         // preparing MessageBuffer for serializing data

   946         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

   947     }

   948 

   949     if (err == kErpcStatus_Success)

   950     {

   951         // preparing codec for serializing data

   952         codec->reset(transport->reserveHeaderSize());

   953 

   954         // Build response message.

   955         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_NewPLCId, sequence);

   956 

   957         codec->write(success);

   958 

   959         codec->write(result);

   960 

   961         err = codec->getStatus();

   962     }

   963 

   964     erpc_free(md5sum);

   965 

   966     if (plcObjectBlobID)

   967     {

   968         free_binary_t_struct(plcObjectBlobID);

   969     }

   970     erpc_free(plcObjectBlobID);

   971 

   972     if (extrafiles)

   973     {

   974         free_list_extra_file_1_t_struct(extrafiles);

   975     }

   976     erpc_free(extrafiles);

   977 

   978     return err;

   979 }

   980 

   981 // Server shim for PurgeBlobs of BeremizPLCObjectService interface.

   982 erpc_status_t BeremizPLCObjectService_service::PurgeBlobs_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   983 {

   984     erpc_status_t err = kErpcStatus_Success;

   985 

   986     uint32_t result;

   987 

   988     // startReadMessage() was already called before this shim was invoked.

   989 

   990     err = codec->getStatus();

   991     if (err == kErpcStatus_Success)

   992     {

   993         // Invoke the actual served function.

   994 #if ERPC_NESTED_CALLS_DETECTION

   995         nestingDetection = true;

   996 #endif

   997         result = m_handler->PurgeBlobs();

   998 #if ERPC_NESTED_CALLS_DETECTION

   999         nestingDetection = false;

  1000 #endif

  1001 

  1002         // preparing MessageBuffer for serializing data

  1003         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

  1004     }

  1005 

  1006     if (err == kErpcStatus_Success)

  1007     {

  1008         // preparing codec for serializing data

  1009         codec->reset(transport->reserveHeaderSize());

  1010 

  1011         // Build response message.

  1012         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_PurgeBlobsId, sequence);

  1013 

  1014         codec->write(result);

  1015 

  1016         err = codec->getStatus();

  1017     }

  1018 

  1019     return err;

  1020 }

  1021 

  1022 // Server shim for RepairPLC of BeremizPLCObjectService interface.

  1023 erpc_status_t BeremizPLCObjectService_service::RepairPLC_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

  1024 {

  1025     erpc_status_t err = kErpcStatus_Success;

  1026 

  1027     uint32_t result;

  1028 

  1029     // startReadMessage() was already called before this shim was invoked.

  1030 

  1031     err = codec->getStatus();

  1032     if (err == kErpcStatus_Success)

  1033     {

  1034         // Invoke the actual served function.

  1035 #if ERPC_NESTED_CALLS_DETECTION

  1036         nestingDetection = true;

  1037 #endif

  1038         result = m_handler->RepairPLC();

  1039 #if ERPC_NESTED_CALLS_DETECTION

  1040         nestingDetection = false;

  1041 #endif

  1042 

  1043         // preparing MessageBuffer for serializing data

  1044         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

  1045     }

  1046 

  1047     if (err == kErpcStatus_Success)

  1048     {

  1049         // preparing codec for serializing data

  1050         codec->reset(transport->reserveHeaderSize());

  1051 

  1052         // Build response message.

  1053         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_RepairPLCId, sequence);

  1054 

  1055         codec->write(result);

  1056 

  1057         err = codec->getStatus();

  1058     }

  1059 

  1060     return err;

  1061 }

  1062 

  1063 // Server shim for ResetLogCount of BeremizPLCObjectService interface.

  1064 erpc_status_t BeremizPLCObjectService_service::ResetLogCount_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

  1065 {

  1066     erpc_status_t err = kErpcStatus_Success;

  1067 

  1068     uint32_t result;

  1069 

  1070     // startReadMessage() was already called before this shim was invoked.

  1071 

  1072     err = codec->getStatus();

  1073     if (err == kErpcStatus_Success)

  1074     {

  1075         // Invoke the actual served function.

  1076 #if ERPC_NESTED_CALLS_DETECTION

  1077         nestingDetection = true;

  1078 #endif

  1079         result = m_handler->ResetLogCount();

  1080 #if ERPC_NESTED_CALLS_DETECTION

  1081         nestingDetection = false;

  1082 #endif

  1083 

  1084         // preparing MessageBuffer for serializing data

  1085         err = messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize());

  1086     }

  1087 

  1088     if (err == kErpcStatus_Success)

  1089     {

  1090         // preparing codec for serializing data

  1091         codec->reset(transport->reserveHeaderSize());

  1092 

  1093         // Build response message.

  1094         codec->startWriteMessage(message_type_t::kReplyMessage, BeremizPLCObjectService_interface::m_serviceId, BeremizPLCObjectService_interface::m_ResetLogCountId, sequence);

  1095 

  1096         codec->write(result);

  1097 

  1098         err = codec->getStatus();

  1099     }

  1100 

  1101     return err;

  1102 }

  1103 

  1104 // Server shim for SeedBlob of BeremizPLCObjectService interface.

  1105 erpc_status_t BeremizPLCObjectService_service::SeedBlob_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

  1106 {

  1107     erpc_status_t err = kErpcStatus_Success;

  1108 

  1109     binary_t *seed = NULL;

  1110     seed = (binary_t *) erpc_malloc(sizeof(binary_t));

  1111     if (seed == NULL)

  1112     {

  1113         codec->updateStatus(kErpcStatus_MemoryError);

  1114     }

  1115     binary_t *blobID = NULL;

  1116     uint32_t result;

  1117 

  1118     // startReadMessage() was already called before this shim was invoked.

  1119 

  1120     read_binary_t_struct(codec, seed);

  1121 

  1122     blobID = (binary_t *) erpc_malloc(sizeof(binary_t));

  1123     if (blobID == NULL)

  1124     {

  1125         codec->updateStatus(kErpcStatus_MemoryError);

  1126     }

  1127 

  1128     err = codec->getStatus();

  1129     if (err == kErpcStatus_Success)

  1130     {

  1131         // Invoke the actual served function.

  1132 #if ERPC_NESTED_CALLS_DETECTION

  1133         nestingDetection = true;

  1134 #endif

  1135         result = m_handler->SeedBlob(seed, blobID);

  1136 #if ERPC_NESTED_CALLS_DETECTION