1

     2

#include <string.h>

     3

#include <filesystem>

     4

#include <dlfcn.h>

     5

#include <fstream>

     6

#include <iostream>

     7

#include <vector>

     8

     9

#include "Logging.hpp"

    10

    11

#include "PLCObject.hpp"

    12

    13

#include "beremiz.h"

    14

    15

    16

// File name of the last transferred PLC md5 hex digest

    17

// with typo in the name, for compatibility with Python runtime

    18

#define LastTransferredPLC "lasttransferedPLC.md5"

    19

    20

// File name of the extra files list

    21

#define ExtraFilesList "extra_files.txt"

    22

    23

    24

    25

PLCObject::PLCObject(void)

    26

{

    27

    m_status.PLCstatus = Empty;

    28

    m_handle = NULL;

    29

    m_debugToken = 0;

    30

    m_argc = 0;

    31

    m_argv = NULL;

    32

    m_PSK_ID = "";

    33

    m_PSK_secret = "";

    34

}

    35

    36

PLCObject::~PLCObject(void)

    37

{

    38

}

    39

    40

uint32_t PLCObject::AppendChunkToBlob(

    41

    const binary_t *data, const binary_t *blobID, binary_t *newBlobID)

    42

{

    43

    // Append data to blob with given blobID

    44

    // Output new blob's md5 into newBlobID

    45

    // Return 0 if success

    46

    47

    newBlobID->data = (uint8_t *)malloc(MD5::digestsize);

    48

    if (newBlobID->data == NULL)

    49

    {

    50

        return ENOMEM;

    51

    }

    52

    53

    std::vector<uint8_t> k(blobID->data, blobID->data + blobID->dataLength);

    54

    55

    auto nh = m_mapBlobIDToBlob.extract(k);

    56

    if (nh.empty())

    57

    {

    58

        return ENOENT;

    59

    }

    60

    61

    Blob *blob = nh.mapped();

    62

    63

    uint32_t res = blob->appendChunk(data->data, data->dataLength);

    64

    if (res != 0)

    65

    {

    66

        return res;

    67

    }

    68

    69

    MD5::digest_t digest = blob->digest();

    70

    71

    std::vector<uint8_t> nk((uint8_t*)digest.data, (uint8_t*)digest.data + MD5::digestsize);

    72

    nh.key() = nk;

    73

    74

    m_mapBlobIDToBlob.insert(std::move(nh));

    75

    76

    memcpy(newBlobID->data, digest.data, MD5::digestsize);

    77

    newBlobID->dataLength = MD5::digestsize;

    78

    79

    return 0;

    80

}

    81

    82

#define LOG_READ_BUFFER_SIZE 1 << 10 // 1KB

    83

    84

uint32_t PLCObject::GetLogMessage(

    85

    uint8_t level, uint32_t msgID, log_message *message)

    86

{

    87

    char buf[LOG_READ_BUFFER_SIZE];

    88

    uint32_t tick;

    89

    uint32_t tv_sec;

    90

    uint32_t tv_nsec;

    91

    92

    uint32_t resultLen = m_PLCSyms.GetLogMessage(

    93

        level, msgID, buf, LOG_READ_BUFFER_SIZE - 1,

    94

        &tick, &tv_sec, &tv_nsec);

    95

    96

    if (resultLen == 0)

    97

    {

    98

        return ENOENT;

    99

    }

   100

   101

    // Get log message with given msgID

   102

    message->msg = (char *)malloc(resultLen);

   103

    if (message->msg == NULL)

   104

    {

   105

        return ENOMEM;

   106

    }

   107

    // Copy the log message into eRPC message

   108

    memcpy(message->msg, buf, resultLen);

   109

    message->msg[resultLen + 1] = '\0';

   110

   111

    message->tick = tick;

   112

    message->sec = tv_sec;

   113

    message->nsec = tv_nsec;

   114

   115

    return 0;

   116

}

   117

   118

uint32_t PLCObject::GetPLCID(PSKID *plcID)

   119

{

   120

    // Get PSK ID

   121

    plcID->ID = (char *)malloc(m_PSK_ID.size() + 1);

   122

    if (plcID->ID == NULL)

   123

    {

   124

        return ENOMEM;

   125

    }

   126

    memcpy(plcID->ID, m_PSK_ID.c_str(), m_PSK_ID.size());

   127

    plcID->ID[m_PSK_ID.size()] = '\0';

   128

   129

    // Get PSK secret

   130

    plcID->PSK = (char *)malloc(m_PSK_secret.size() + 1);

   131

    if (plcID->PSK == NULL)

   132

    {

   133

        free(plcID->ID);

   134

        return ENOMEM;

   135

    }

   136

    memcpy(plcID->PSK, m_PSK_secret.c_str(), m_PSK_secret.size());

   137

    plcID->PSK[m_PSK_secret.size()] = '\0';

   138

   139

    return 0;

   140

}

   141

   142

uint32_t PLCObject::GetPLCstatus(PLCstatus *status)

   143

{

   144

    // Get PLC status

   145

    *status = m_status;

   146

    return 0;

   147

}

   148

   149

uint32_t PLCObject::GetTraceVariables(

   150

    uint32_t debugToken, TraceVariables *traces)

   151

{

   152

    if(debugToken != m_debugToken)

   153

    {

   154

        return EINVAL;

   155

    }

   156

   157

    // Check if there are any traces

   158

    m_tracesMutex.lock();

   159

    size_t sz = m_traces.size();

   160

    if(sz > 0)

   161

    {

   162

        // Allocate memory for traces

   163

        traces->traces.elements = (trace_sample *)malloc(sz * sizeof(trace_sample));

   164

        if(traces->traces.elements == NULL)

   165

        {

   166

            m_tracesMutex.unlock();

   167

            return ENOMEM;

   168

        }

   169

        // Copy traces from vector

   170

        memcpy(traces->traces.elements, m_traces.data(), sz * sizeof(trace_sample));

   171

   172

        // Clear the vector

   173

        // note that the data is not freed here, it is meant to be freed by eRPC server code

   174

        m_traces.clear();

   175

    }

   176

    m_tracesMutex.unlock();

   177

   178

    traces->traces.elementsCount = sz;

   179

    traces->PLCstatus = m_status.PLCstatus;

   180

   181

    return 0;

   182

}

   183

   184

uint32_t PLCObject::MatchMD5(const char *MD5, bool *match)

   185

{

   186

    // an empty PLC is never considered to match

   187

    if(m_status.PLCstatus == Empty)

   188

    {

   189

        *match = false;

   190

        return 0;

   191

    }

   192

   193

    // Load the last transferred PLC md5 hex digest

   194

    std::string md5sum;

   195

    try {

   196

        std::ifstream(std::string(LastTransferredPLC), std::ios::binary) >> md5sum;

   197

    } catch (std::exception e) {

   198

        *match = false;

   199

        return 0;

   200

    }

   201

   202

    // Compare the given MD5 with the last transferred PLC md5

   203

    *match = (md5sum == MD5);

   204

   205

    return 0;

   206

}

   207

   208

#if defined(_WIN32) || defined(_WIN64)

   209

// For Windows platform

   210

#define SHARED_OBJECT_EXT ".dll"

   211

#elif defined(__APPLE__) || defined(__MACH__)

   212

// For MacOS platform

   213

#define SHARED_OBJECT_EXT ".dylib"

   214

#else

   215

// For Linux/Unix platform

   216

#define SHARED_OBJECT_EXT ".so"

   217

#endif

   218

   219

uint32_t PLCObject::BlobAsFile(

   220

    const binary_t *BlobID, std::filesystem::path filename)

   221

{

   222

    // Extract the blob from the map

   223

    auto nh = m_mapBlobIDToBlob.extract(

   224

        std::vector<uint8_t>(BlobID->data, BlobID->data + BlobID->dataLength));

   225

    if (nh.empty())

   226

    {

   227

        return ENOENT;

   228

    }

   229

    Blob *blob = nh.mapped();

   230

   231

    // Realize the blob into a file

   232

    uint32_t res = blob->asFile(filename);

   233

   234

    delete blob;

   235

   236

    if (res != 0)

   237

    {

   238

        return res;

   239

    }

   240

    return 0;

   241

}

   242

   243

uint32_t PLCObject::NewPLC(

   244

    const char *md5sum, const binary_t *plcObjectBlobID,

   245

    const list_extra_file_1_t *extrafiles, bool *success)

   246

{

   247

    if(m_status.PLCstatus == Started)

   248

    {

   249

        *success = false;

   250

        return EBUSY;

   251

    }

   252

   253

    if(m_status.PLCstatus == Broken)

   254

    {

   255

        *success = false;

   256

        return EINVAL;

   257

    }

   258

   259

    // Unload the PLC object

   260

    UnLoadPLC();

   261

   262

    // Purge the PLC object

   263

    PurgePLC();

   264

   265

    // Concatenate md5sum and shared object extension to obtain filename

   266

    std::filesystem::path filename =

   267

        std::filesystem::path(md5sum) += SHARED_OBJECT_EXT;

   268

   269

    // Create the PLC object shared object file

   270

    BlobAsFile(plcObjectBlobID, filename);

   271

   272

    // create "lasttransferedPLC.md5" file and Save md5sum in it

   273

    std::ofstream(std::string(LastTransferredPLC), std::ios::binary) << md5sum;

   274

   275

    // create "extra_files.txt" file

   276

    std::ofstream extra_files_log(std::string(ExtraFilesList), std::ios::binary);

   277

   278

    // Create extra files

   279

    for (int i = 0; i < extrafiles->elementsCount; i++)

   280

    {

   281

        extra_file *extrafile = extrafiles->elements + i;

   282

   283

        BlobAsFile(plcObjectBlobID, extrafile->fname);

   284

   285

        // Save the extra file name in "extra_files.txt"

   286

        extra_files_log << extrafile->fname << std::endl;

   287

    }

   288

   289

    // Load the PLC object

   290

    uint32_t res = LoadPLC();

   291

    if (res != 0)

   292

    {

   293

        *success = false;

   294

        return res;

   295

    }

   296

   297

    m_status.PLCstatus = Stopped;

   298

    *success = true;

   299

   300

    return 0;

   301

}

   302

   303

#define DLSYM(sym)                                                           \

   304

    do                                                                       \

   305

    {                                                                        \

   306

        m_PLCSyms.sym = (decltype(m_PLCSyms.sym))dlsym(m_handle, #sym);      \

   307

        if (m_PLCSyms.sym == NULL)                                           \

   308

        {                                                                    \

   309

            /* TODO: use log instead */                                      \

   310

            std::cout << "Error dlsym " #sym ": " << dlerror() << std::endl; \

   311

            return errno;                                                    \

   312

        }                                                                    \

   313

    } while (0);

   314

   315

uint32_t PLCObject::LoadPLC(void)

   316

{

   317

    // Load the last transferred PLC md5 hex digest

   318

    std::string md5sum;

   319

    try {

   320

        std::ifstream(std::string(LastTransferredPLC), std::ios::binary) >> md5sum;

   321

    } catch (std::exception e) {

   322

        return ENOENT;

   323

    }

   324

   325

    // Concatenate md5sum and shared object extension to obtain filename

   326

    std::filesystem::path filename(md5sum + SHARED_OBJECT_EXT);

   327

   328

    // Load the shared object file

   329

    m_handle = dlopen(std::filesystem::absolute(filename).c_str(), RTLD_NOW);

   330

    if (m_handle == NULL)

   331

    {

   332

        std::cout << "Error: " << dlerror() << std::endl;

   333

        return errno;

   334

    }

   335

   336

    // Resolve shared object symbols

   337

    FOR_EACH_PLC_SYMBOLS_DO(DLSYM);

   338

   339

    // Set content of PLC_ID to md5sum

   340

    m_PLCSyms.PLC_ID = (uint8_t *)malloc(md5sum.size() + 1);

   341

    if (m_PLCSyms.PLC_ID == NULL)

   342

    {

   343

        return ENOMEM;

   344

    }

   345

    memcpy(m_PLCSyms.PLC_ID, md5sum.c_str(), md5sum.size());

   346

    m_PLCSyms.PLC_ID[md5sum.size()] = '\0';

   347

   348

    return 0;

   349

}

   350

   351

#define ULSYM(sym)            \

   352

    do                        \

   353

    {                         \

   354

        m_PLCSyms.sym = NULL; \

   355

    } while (0);

   356

   357

uint32_t PLCObject::UnLoadPLC(void)

   358

{

   359

    // Unload the shared object file

   360

    FOR_EACH_PLC_SYMBOLS_DO(ULSYM);

   361

    if(m_handle != NULL)

   362

    {

   363

        dlclose(m_handle);

   364

        m_handle = NULL;

   365

    }

   366

    return 0;

   367

}

   368

   369

uint32_t PLCObject::PurgeBlobs(void)

   370

{

   371

    // Purge all blobs

   372

   373

    for (auto &blob : m_mapBlobIDToBlob)

   374

    {

   375

        delete blob.second;

   376

    }

   377

    m_mapBlobIDToBlob.clear();

   378

   379

    return 0;

   380

}

   381

   382

uint32_t PLCObject::PurgePLC(void)

   383

{

   384

   385

    // Open the extra files list

   386

    std::ifstream extra_files_log(std::string(ExtraFilesList), std::ios::binary);

   387

   388

    // Remove extra files

   389

    std::string extra_file;

   390

    while (std::getline(extra_files_log, extra_file))

   391

    {

   392

        std::filesystem::remove(extra_file);

   393

    }

   394

   395

    // Load the last transferred PLC md5 hex digest

   396

    std::string md5sum;

   397

    try {

   398

        std::ifstream(std::string(LastTransferredPLC), std::ios::binary) >> md5sum;

   399

   400

        // Remove the PLC object shared object file

   401

        std::filesystem::remove(md5sum + SHARED_OBJECT_EXT);

   402

    } catch (std::exception e) {

   403

        // ignored

   404

    }

   405

   406

    try {

   407

        // Remove the last transferred PLC md5 hex digest

   408

        std::filesystem::remove(std::string(LastTransferredPLC));

   409

   410

        // Remove the extra files list

   411

        std::filesystem::remove(std::string(ExtraFilesList));

   412

    } catch (std::exception e) {

   413

        // ignored

   414

    }

   415

   416

    return 0;

   417

}

   418

   419

uint32_t PLCObject::RepairPLC(void)

   420

{

   421

    // Repair the PLC object

   422

   423

    if(m_status.PLCstatus == Broken)

   424

    {

   425

        // Unload the PLC object

   426

        UnLoadPLC();

   427

   428

        // Purge the PLC object

   429

        PurgePLC();

   430

    }

   431

   432

   433

    LogMessage(LOG_WARNING, "RepairPLC not implemented");

   434

    return 0;

   435

}

   436

   437

uint32_t PLCObject::ResetLogCount(void)

   438

{

   439

    m_PLCSyms.ResetLogCount();

   440

    return 0;

   441

}

   442

   443

uint32_t PLCObject::SeedBlob(const binary_t *seed, binary_t *blobID)

   444

{

   445

    // Create a blob with given seed

   446

    // Output new blob's md5 into blobID

   447

    // Return 0 if success

   448

   449

    Blob *blob = NULL;

   450

    try

   451

    {

   452

        blob = new Blob(seed->data, seed->dataLength);

   453

    }

   454

    catch (int e)

   455

    {

   456

        return e;

   457

    }

   458

   459

    MD5::digest_t digest = blob->digest();

   460

   461

    std::vector<uint8_t> k((uint8_t*)digest.data, (uint8_t*)digest.data + MD5::digestsize);

   462

   463

    m_mapBlobIDToBlob[k] = blob;

   464

   465

    blobID->data = (uint8_t *)malloc(MD5::digestsize);

   466

    if (blobID->data == NULL)

   467

    {

   468

        return ENOMEM;

   469

    }

   470

    memcpy(blobID->data, digest.data, MD5::digestsize);

   471

    blobID->dataLength = MD5::digestsize;

   472

   473

    return 0;

   474

}

   475

void PLCObject::PurgeTraceBuffer(void)

   476

{

   477

    // Free trace buffer

   478

    m_tracesMutex.lock();

   479

    for(trace_sample s : m_traces){

   480

        free(s.TraceBuffer.data);

   481

    }

   482

    m_traces.clear();

   483

    m_tracesMutex.unlock();

   484

}

   485

   486

uint32_t PLCObject::SetTraceVariablesList(

   487

    const list_trace_order_1_t *orders, int32_t *debugtoken)

   488

{

   489

    if(m_status.PLCstatus == Empty)

   490

    {

   491

        return EINVAL;

   492

    }

   493

   494

    // increment debug token