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

uint32_t PLCObject::AutoLoad()

    83

{

    84

    // Load PLC object

    85

    uint32_t res = LoadPLC();

    86

    if (res != 0)

    87

    {

    88

        return res;

    89

    }

    90

    91

    // Start PLC object

    92

    res = StartPLC();

    93

    if (res != 0)

    94

    {

    95

        return res;

    96

    }

    97

    98

    return 0;

    99

}

   100

   101

   102

#define LOG_READ_BUFFER_SIZE 1 << 10 // 1KB

   103

   104

uint32_t PLCObject::GetLogMessage(

   105

    uint8_t level, uint32_t msgID, log_message *message)

   106

{

   107

    char buf[LOG_READ_BUFFER_SIZE];

   108

    uint32_t tick;

   109

    uint32_t tv_sec;

   110

    uint32_t tv_nsec;

   111

   112

    uint32_t resultLen;

   113

    if(m_status.PLCstatus == Empty){

   114

        resultLen = 0;

   115

    } else {

   116

        resultLen = m_PLCSyms.GetLogMessage(

   117

            level, msgID, buf, LOG_READ_BUFFER_SIZE - 1,

   118

            &tick, &tv_sec, &tv_nsec);

   119

    }

   120

   121

    // Get log message with given msgID

   122

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

   123

    if (message->msg == NULL)

   124

    {

   125

        return ENOMEM;

   126

    }

   127

    // Copy the log message into eRPC message

   128

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

   129

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

   130

   131

    message->tick = tick;

   132

    message->sec = tv_sec;

   133

    message->nsec = tv_nsec;

   134

   135

    return 0;

   136

}

   137

   138

uint32_t PLCObject::GetPLCID(PSKID *plcID)

   139

{

   140

    // Get PSK ID

   141

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

   142

    if (plcID->ID == NULL)

   143

    {

   144

        return ENOMEM;

   145

    }

   146

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

   147

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

   148

   149

    // Get PSK secret

   150

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

   151

    if (plcID->PSK == NULL)

   152

    {

   153

        free(plcID->ID);

   154

        return ENOMEM;

   155

    }

   156

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

   157

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

   158

   159

    return 0;

   160

}

   161

   162

uint32_t PLCObject::GetPLCstatus(PLCstatus *status)

   163

{

   164

    if(m_status.PLCstatus == Empty){        

   165

        for(int lvl = 0; lvl < 4; lvl++){

   166

            m_status.logcounts[lvl] = 0;

   167

        }

   168

    } else {

   169

        // Get log counts

   170

        for(int lvl = 0; lvl < 4; lvl++){

   171

            m_status.logcounts[lvl] = m_PLCSyms.GetLogCount(lvl);

   172

        }

   173

    }

   174

    // Get PLC status

   175

    *status = m_status;

   176

    return 0;

   177

}

   178

   179

uint32_t PLCObject::GetTraceVariables(

   180

    uint32_t debugToken, TraceVariables *traces)

   181

{

   182

    if(debugToken != m_debugToken)

   183

    {

   184

        return EINVAL;

   185

    }

   186

   187

    // Check if there are any traces

   188

    m_tracesMutex.lock();

   189

    size_t sz = m_traces.size();

   190

    if(sz > 0)

   191

    {

   192

        // Allocate memory for traces

   193

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

   194

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

   195

        {

   196

            m_tracesMutex.unlock();

   197

            return ENOMEM;

   198

        }

   199

        // Copy traces from vector

   200

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

   201

   202

        // Clear the vector

   203

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

   204

        m_traces.clear();

   205

    }

   206

    m_tracesMutex.unlock();

   207

   208

    traces->traces.elementsCount = sz;

   209

    traces->PLCstatus = m_status.PLCstatus;

   210

   211

    return 0;

   212

}

   213

   214

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

   215

{

   216

    // an empty PLC is never considered to match

   217

    if(m_status.PLCstatus == Empty)

   218

    {

   219

        *match = false;

   220

        return 0;

   221

    }

   222

   223

    // Load the last transferred PLC md5 hex digest

   224

    std::string md5sum;

   225

    try {

   226

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

   227

    } catch (std::exception e) {

   228

        *match = false;

   229

        return 0;

   230

    }

   231

   232

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

   233

    *match = (md5sum == MD5);

   234

   235

    return 0;

   236

}

   237

   238

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

   239

// For Windows platform

   240

#define SHARED_OBJECT_EXT ".dll"

   241

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

   242

// For MacOS platform

   243

#define SHARED_OBJECT_EXT ".dylib"

   244

#else

   245

// For Linux/Unix platform

   246

#define SHARED_OBJECT_EXT ".so"

   247

#endif

   248

   249

uint32_t PLCObject::BlobAsFile(

   250

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

   251

{

   252

    // Extract the blob from the map

   253

    auto nh = m_mapBlobIDToBlob.extract(

   254

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

   255

    if (nh.empty())

   256

    {

   257

        return ENOENT;

   258

    }

   259

    Blob *blob = nh.mapped();

   260

   261

    // Realize the blob into a file

   262

    uint32_t res = blob->asFile(filename);

   263

   264

    delete blob;

   265

   266

    if (res != 0)

   267

    {

   268

        return res;

   269

    }

   270

    return 0;

   271

}

   272

   273

uint32_t PLCObject::NewPLC(

   274

    const char *md5sum, const binary_t *plcObjectBlobID,

   275

    const list_extra_file_1_t *extrafiles, bool *success)

   276

{

   277

    if(m_status.PLCstatus == Started)

   278

    {

   279

        *success = false;

   280

        return EBUSY;

   281

    }

   282

   283

    if(m_status.PLCstatus == Broken)

   284

    {

   285

        *success = false;

   286

        return EINVAL;

   287

    }

   288

   289

    // Unload the PLC object

   290

    UnLoadPLC();

   291

   292

    // Purge the PLC object

   293

    PurgePLC();

   294

   295

    // Concatenate md5sum and shared object extension to obtain filename

   296

    std::filesystem::path filename =

   297

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

   298

   299

    // Create the PLC object shared object file

   300

    BlobAsFile(plcObjectBlobID, filename);

   301

   302

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

   303

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

   304

   305

    // create "extra_files.txt" file

   306

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

   307

   308

    // Create extra files

   309

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

   310

    {

   311

        extra_file *extrafile = extrafiles->elements + i;

   312

   313

        BlobAsFile(plcObjectBlobID, extrafile->fname);

   314

   315

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

   316

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

   317

    }

   318

   319

    // Load the PLC object

   320

    uint32_t res = LoadPLC();

   321

    if (res != 0)

   322

    {

   323

        *success = false;

   324

        return res;

   325

    }

   326

   327

    m_status.PLCstatus = Stopped;

   328

    *success = true;

   329

   330

    return 0;

   331

}

   332

   333

#define DLSYM(sym)                                                           \

   334

    do                                                                       \

   335

    {                                                                        \

   336

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

   337

        if (m_PLCSyms.sym == NULL)                                           \

   338

        {                                                                    \

   339

            /* TODO: use log instead */                                      \

   340

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

   341

            return errno;                                                    \

   342

        }                                                                    \

   343

    } while (0);

   344

   345

uint32_t PLCObject::LoadPLC(void)

   346

{

   347

    // Load the last transferred PLC md5 hex digest

   348

    std::string md5sum;

   349

    try {

   350

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

   351

    } catch (std::exception e) {

   352

        return ENOENT;

   353

    }

   354

   355

    // Concatenate md5sum and shared object extension to obtain filename

   356

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

   357

   358

    // Load the shared object file

   359

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

   360

    if (m_handle == NULL)

   361

    {

   362

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

   363

        return errno;

   364

    }

   365

   366

    // Resolve shared object symbols

   367

    FOR_EACH_PLC_SYMBOLS_DO(DLSYM);

   368

   369

    // Set content of PLC_ID to md5sum

   370

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

   371

    if (m_PLCSyms.PLC_ID == NULL)

   372

    {

   373

        return ENOMEM;

   374

    }

   375

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

   376

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

   377

   378

    return 0;

   379

}

   380

   381

#define ULSYM(sym)            \

   382

    do                        \

   383

    {                         \

   384

        m_PLCSyms.sym = NULL; \

   385

    } while (0);

   386

   387

uint32_t PLCObject::UnLoadPLC(void)

   388

{

   389

    // Unload the shared object file

   390

    FOR_EACH_PLC_SYMBOLS_DO(ULSYM);

   391

    if(m_handle != NULL)

   392

    {

   393

        dlclose(m_handle);

   394

        m_handle = NULL;

   395

    }

   396

    return 0;

   397

}

   398

   399

uint32_t PLCObject::PurgeBlobs(void)

   400

{

   401

    // Purge all blobs

   402

   403

    for (auto &blob : m_mapBlobIDToBlob)

   404

    {

   405

        delete blob.second;

   406

    }

   407

    m_mapBlobIDToBlob.clear();

   408

   409

    return 0;

   410

}

   411

   412

uint32_t PLCObject::PurgePLC(void)

   413

{

   414

   415

    // Open the extra files list

   416

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

   417

   418

    // Remove extra files

   419

    std::string extra_file;

   420

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

   421

    {

   422

        std::filesystem::remove(extra_file);

   423

    }

   424

   425

    // Load the last transferred PLC md5 hex digest

   426

    std::string md5sum;

   427

    try {

   428

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

   429

   430

        // Remove the PLC object shared object file

   431

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

   432

    } catch (std::exception e) {

   433

        // ignored

   434

    }

   435

   436

    try {

   437

        // Remove the last transferred PLC md5 hex digest

   438

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

   439

   440

        // Remove the extra files list

   441

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

   442

    } catch (std::exception e) {

   443

        // ignored

   444

    }

   445

   446

    return 0;

   447

}

   448

   449

uint32_t PLCObject::RepairPLC(void)

   450

{

   451

    // Repair the PLC object

   452

   453

    if(m_status.PLCstatus == Broken)

   454

    {

   455

        // Unload the PLC object

   456

        UnLoadPLC();

   457

   458

        // Purge the PLC object

   459

        PurgePLC();

   460

    }

   461

   462

   463

    LogMessage(LOG_WARNING, "RepairPLC not implemented");

   464

    return 0;

   465

}

   466

   467

uint32_t PLCObject::ResetLogCount(void)

   468

{

   469

    m_PLCSyms.ResetLogCount();

   470

    return 0;

   471

}

   472

   473

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

   474

{

   475

    // Create a blob with given seed

   476

    // Output new blob's md5 into blobID

   477

    // Return 0 if success

   478

   479

    Blob *blob = NULL;

   480

    try

   481

    {

   482

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

   483

    }

   484

    catch (int e)

   485

    {

   486

        return e;

   487

    }

   488

   489

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

   490

   491

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

   492

   493

    m_mapBlobIDToBlob[k] = blob;

   494