1

     2

#include <string.h>

     3

#include <filesystem>

     4

#include <dlfcn.h>

     5

#include <fstream>

     6

#include <iostream>

     7

     8

#include "Logging.hpp"

     9

    10

#include "PLCObject.hpp"

    11

    12

#include "beremiz.h"

    13

    14

    15

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

    16

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

    17

#define LastTransferredPLC "lasttransferedPLC.md5"

    18

    19

// File name of the extra files list

    20

#define ExtraFilesList "extra_files.txt"

    21

    22

    23

    24

PLCObject::PLCObject(void)

    25

{

    26

}

    27

    28

PLCObject::~PLCObject(void)

    29

{

    30

}

    31

    32

uint32_t PLCObject::AppendChunkToBlob(

    33

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

    34

{

    35

    // Append data to blob with given blobID

    36

    // Output new blob's md5 into newBlobID

    37

    // Return 0 if success

    38

    39

    auto nh = m_mapBlobIDToBlob.extract(std::vector<uint8_t>(

    40

        blobID->data, blobID->data + blobID->dataLength));

    41

    if (nh.empty())

    42

    {

    43

        return ENOENT;

    44

    }

    45

    46

    Blob *blob = nh.mapped();

    47

    48

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

    49

    if (res != 0)

    50

    {

    51

        return res;

    52

    }

    53

    54

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

    55

    56

    nh.key() = std::vector<uint8_t>(

    57

        (uint8_t)*digest.data, (uint8_t)*digest.data + MD5::digestsize);

    58

    59

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

    60

    61

    return 0;

    62

}

    63

    64

#define LOG_READ_BUFFER_SIZE 1 << 10 // 1KB

    65

    66

uint32_t PLCObject::GetLogMessage(

    67

    uint8_t level, uint32_t msgID, log_message *message)

    68

{

    69

    char buf[LOG_READ_BUFFER_SIZE];

    70

    uint32_t tick;

    71

    uint32_t tv_sec;

    72

    uint32_t tv_nsec;

    73

    74

    uint32_t resultLen = m_PLCSyms.GetLogMessage(

    75

        level, msgID, buf, LOG_READ_BUFFER_SIZE - 1,

    76

        &tick, &tv_sec, &tv_nsec);

    77

    78

    if (resultLen == 0)

    79

    {

    80

        return ENOENT;

    81

    }

    82

    83

    // Get log message with given msgID

    84

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

    85

    if (message->msg == NULL)

    86

    {

    87

        return ENOMEM;

    88

    }

    89

    // Copy the log message into eRPC message

    90

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

    91

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

    92

    93

    message->tick = tick;

    94

    message->sec = tv_sec;

    95

    message->nsec = tv_nsec;

    96

    97

    return 0;

    98

}

    99

   100

uint32_t PLCObject::GetPLCID(PSKID *plcID)

   101

{

   102

    // Get PLC ID

   103

    *plcID = m_plcID;

   104

    return 0;

   105

}

   106

   107

uint32_t PLCObject::GetPLCstatus(PLCstatus *status)

   108

{

   109

    // Get PLC status

   110

    *status = m_status;

   111

    return 0;

   112

}

   113

   114

uint32_t PLCObject::GetTraceVariables(

   115

    uint32_t debugToken, TraceVariables *traces)

   116

{

   117

    // XXX TODO

   118

    return 0;

   119

}

   120

   121

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

   122

{

   123

    // Load the last transferred PLC md5 hex digest

   124

    std::string md5sum;

   125

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

   126

   127

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

   128

    *match = (md5sum == MD5);

   129

   130

    return 0;

   131

}

   132

   133

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

   134

// For Windows platform

   135

#define SHARED_OBJECT_EXT ".dll"

   136

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

   137

// For MacOS platform

   138

#define SHARED_OBJECT_EXT ".dylib"

   139

#else

   140

// For Linux/Unix platform

   141

#define SHARED_OBJECT_EXT ".so"

   142

#endif

   143

   144

uint32_t PLCObject::BlobAsFile(

   145

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

   146

{

   147

    // Extract the blob from the map

   148

    auto nh = m_mapBlobIDToBlob.extract(

   149

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

   150

    if (nh.empty())

   151

    {

   152

        return ENOENT;

   153

    }

   154

    Blob *blob = nh.mapped();

   155

   156

    // Realize the blob into a file

   157

    uint32_t res = blob->asFile(filename);

   158

   159

    delete blob;

   160

   161

    if (res != 0)

   162

    {

   163

        return res;

   164

    }

   165

    return 0;

   166

}

   167

   168

uint32_t PLCObject::NewPLC(

   169

    const char *md5sum, const binary_t *plcObjectBlobID,

   170

    const list_extra_file_1_t *extrafiles, bool *success)

   171

{

   172

    // Concatenate md5sum and shared object extension to obtain filename

   173

    std::filesystem::path filename =

   174

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

   175

   176

    // Create the PLC object shared object file

   177

    BlobAsFile(plcObjectBlobID, filename);

   178

   179

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

   180

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

   181

   182

    // create "extra_files.txt" file

   183

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

   184

   185

    // Create extra files

   186

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

   187

    {

   188

        extra_file *extrafile = extrafiles->elements + i;

   189

   190

        BlobAsFile(plcObjectBlobID, extrafile->fname);

   191

   192

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

   193

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

   194

    }

   195

   196

    return 0;

   197

}

   198

   199

#define DLSYM(sym)                                                      \

   200

    do                                                                  \

   201

    {                                                                   \

   202

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

   203

        if (m_PLCSyms.sym == NULL)                                      \

   204

        {                                                               \

   205

            return errno;                                               \

   206

        }                                                               \

   207

    } while (0);

   208

   209

uint32_t PLCObject::LoadPLC(void)

   210

{

   211

    // Load the last transferred PLC md5 hex digest

   212

    std::string md5sum;

   213

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

   214

   215

    // Concatenate md5sum and shared object extension to obtain filename

   216

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

   217

   218

    // Load the shared object file

   219

    m_handle = dlopen(filename.c_str(), RTLD_NOW);

   220

    if (m_handle == NULL)

   221

    {

   222

        return errno;

   223

    }

   224

   225

    // Resolve shared object symbols

   226

    FOR_EACH_PLC_SYMBOLS_DO(DLSYM);

   227

   228

    return 0;

   229

}

   230

   231

#define ULSYM(sym)            \

   232

    do                        \

   233

    {                         \

   234

        m_PLCSyms.sym = NULL; \

   235

    } while (0);

   236

   237

uint32_t PLCObject::UnLoadPLC(void)

   238

{

   239

    // Unload the shared object file

   240

    FOR_EACH_PLC_SYMBOLS_DO(ULSYM);

   241

    dlclose(m_handle);

   242

   243

    return 0;

   244

}

   245

   246

uint32_t PLCObject::PurgeBlobs(void)

   247

{

   248

    // Purge all blobs

   249

   250

    for (auto &blob : m_mapBlobIDToBlob)

   251

    {

   252

        delete blob.second;

   253

    }

   254

    m_mapBlobIDToBlob.clear();

   255

   256

    return 0;

   257

}

   258

   259

uint32_t PLCObject::RepairPLC(void)

   260

{

   261

    // XXX TODO

   262

    LogMessage(LOG_WARNING, "RepairPLC not implemented");

   263

    return 0;

   264

}

   265

   266

uint32_t PLCObject::ResetLogCount(void)

   267

{

   268

    m_PLCSyms.ResetLogCount();

   269

    return 0;

   270

}

   271

   272

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

   273

{

   274

    // Create a blob with given seed

   275

    // Output new blob's md5 into blobID

   276

    // Return 0 if success

   277

   278

    Blob *blob = NULL;

   279

    try

   280

    {

   281

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

   282

    }

   283

    catch (int e)

   284

    {

   285

        return e;

   286

    }

   287

   288

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

   289

   290

    m_mapBlobIDToBlob[std::vector<uint8_t>((uint8_t)*digest.data, (uint8_t)*digest.data + MD5::digestsize)] = blob;

   291

   292

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

   293

    if (blobID->data == NULL)

   294

    {

   295

        return ENOMEM;

   296

    }

   297

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

   298

    blobID->dataLength = MD5::digestsize;

   299

   300

    return 0;

   301

}

   302

   303

uint32_t PLCObject::SetTraceVariablesList(

   304

    const list_trace_order_1_t *orders, uint32_t *debugtoken)

   305

{

   306

    // XXX TODO

   307

    LogMessage(LOG_WARNING, "SetTraceVariablesList not implemented");

   308

    return 0;

   309

}

   310

   311

uint32_t PLCObject::StartPLC(void)

   312

{

   313

    LogMessage(LOG_INFO, "Starting PLC");

   314

    uint32_t res = m_PLCSyms.startPLC(m_argc, m_argv);

   315

    if(res != 0)

   316

    {

   317

        m_status.PLCstatus = Broken;

   318

        return res;

   319

    }

   320

    m_status.PLCstatus = Started;

   321

    return 0;

   322

}

   323

   324

uint32_t PLCObject::StopPLC(bool *success)

   325

{

   326

    LogMessage(LOG_INFO, "Stopping PLC");

   327

    uint32_t res = m_PLCSyms.stopPLC();

   328

    if(res != 0)

   329

    {

   330

        m_status.PLCstatus = Broken;

   331

        return res;

   332

    }

   333

    m_status.PLCstatus = Stopped;

   334

    return 0;

   335

}

   336

   337

uint32_t PLCObject::LogMessage(uint8_t level, std::string message)

   338

{

   339

    // Log std::string message with given level

   340

    return m_PLCSyms.LogMessage(level, (char *)message.c_str(), message.size());

   341

}