projects/stargazer/plugins/other/smux/utils.cpp

   1 #include <unistd.h> // write
   2
   3 #include <cstring> // memset
   4 #include <cerrno>
   5
   6 #include "stg/common.h"
   7
   8 #include "stg/OpenPDU.h"
   9 #include "stg/ClosePDU.h"
  10 #include "stg/RReqPDU.h"
  11 #include "stg/ber_decoder.h"
  12 #include "stg/der_encoder.h"
  13
  14 #include "pen.h"
  15 #include "utils.h"
  16
  17 bool String2OI(const std::string & str, OBJECT_IDENTIFIER_t * oi)
  18 {
  19 size_t left = 0, pos = 0, arcPos = 0;
  20 int arcs[1024];
  21 pos = str.find_first_of('.', left);
  22 if (pos == 0)
  23     {
  24     left = 1;
  25     pos = str.find_first_of('.', left);
  26     }
  27 while (pos != std::string::npos)
  28     {
  29     int arc = 0;
  30     if (str2x(str.substr(left, left - pos), arc))
  31         {
  32         return false;
  33         }
  34     arcs[arcPos++] = arc;
  35     left = pos + 1;
  36     pos = str.find_first_of('.', left);
  37     }
  38 if (left < str.length())
  39     {
  40     int arc = 0;
  41     if (str2x(str.substr(left, left - pos), arc))
  42         {
  43         return false;
  44         }
  45     arcs[arcPos++] = arc;
  46     }
  47 OBJECT_IDENTIFIER_set_arcs(oi, arcs, sizeof(arcs[0]), arcPos);
  48 return true;
  49 }
  50
  51 std::string OI2String(OBJECT_IDENTIFIER_t * oi)
  52 {
  53 std::string res;
  54
  55 int arcs[1024];
  56 int count = OBJECT_IDENTIFIER_get_arcs(oi, arcs, sizeof(arcs[0]), 1024);
  57
  58 if (count > 1024)
  59     return "";
  60
  61 for (int i = 0; i < count; ++i)
  62     {
  63     res += ".";
  64     std::string arc;
  65     strprintf(&arc, "%d", arcs[i]);
  66     res += arc;
  67     }
  68
  69 return res;
  70 }
  71
  72 bool SendOpenPDU(int fd)
  73 {
  74 const char * description = "Stg SMUX Plugin";
  75 asn_enc_rval_t error;
  76 OpenPDU_t msg;
  77
  78 memset(&msg, 0, sizeof(msg));
  79
  80 msg.present = OpenPDU_PR_simple;
  81 asn_long2INTEGER(&msg.choice.simple.version, SimpleOpen__version_version_1);
  82 std::string pen(PEN_PREFIX);
  83 pen += ".1";
  84 if (!String2OI(pen.c_str(), &msg.choice.simple.identity))
  85     {
  86     printfd(__FILE__,
  87             "SendOpenPDU() - failed to convert string to OBJECT_IDENTIFIER\n");
  88     return false;
  89     }
  90 OCTET_STRING_fromString(&msg.choice.simple.description, description);
  91 OCTET_STRING_fromString(&msg.choice.simple.password, "");
  92
  93 char buffer[1024];
  94 error = der_encode_to_buffer(&asn_DEF_OpenPDU, &msg, buffer, sizeof(buffer));
  95
  96 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_OpenPDU, &msg);
  97
  98 if (error.encoded == -1)
  99     {
 100     printfd(__FILE__, "Could not encode OpenPDU (at %s)\n",
 101             error.failed_type ? error.failed_type->name : "unknown");
 102     return false;
 103     }
 104 else
 105     {
 106     if (write(fd, buffer, error.encoded) < 0)
 107         {
 108         printfd(__FILE__, "Failed to send OpenPDU: %s\n", strerror(errno));
 109         return false;
 110         }
 111     }
 112 return true;
 113 }
 114
 115 bool SendClosePDU(int fd)
 116 {
 117 ClosePDU_t msg;
 118
 119 memset(&msg, 0, sizeof(msg));
 120
 121 asn_long2INTEGER(&msg, ClosePDU_goingDown);
 122
 123 char buffer[1024];
 124 asn_enc_rval_t error;
 125 error = der_encode_to_buffer(&asn_DEF_ClosePDU, &msg, buffer, sizeof(buffer));
 126
 127 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_ClosePDU, &msg);
 128
 129 if (error.encoded == -1)
 130     {
 131     printfd(__FILE__, "Could not encode ClosePDU (at %s)\n",
 132             error.failed_type ? error.failed_type->name : "unknown");
 133     return false;
 134     }
 135 else
 136     {
 137     if (write(fd, buffer, error.encoded) < 0)
 138         {
 139         printfd(__FILE__, "Failed to send ClosePDU: %s\n", strerror(errno));
 140         return false;
 141         }
 142     }
 143 return true;
 144 }
 145
 146 bool SendRReqPDU(int fd)
 147 {
 148 int oid[] = {1, 3, 6, 1, 4, 1, 38313, 1};
 149 asn_enc_rval_t error;
 150 RReqPDU_t msg;
 151
 152 memset(&msg, 0, sizeof(msg));
 153
 154 msg.priority = 0;
 155 asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly);
 156 OBJECT_IDENTIFIER_set_arcs(&msg.subtree,
 157                            oid,
 158                            sizeof(oid[0]),
 159                            8);
 160
 161 char buffer[1024];
 162 error = der_encode_to_buffer(&asn_DEF_RReqPDU, &msg, buffer, sizeof(buffer));
 163
 164 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_RReqPDU, &msg);
 165
 166 if (error.encoded == -1)
 167     {
 168     printfd(__FILE__, "Could not encode RReqPDU (at %s)\n",
 169             error.failed_type ? error.failed_type->name : "unknown");
 170     return false;
 171     }
 172 else
 173     {
 174     if (write(fd, buffer, error.encoded) < 0)
 175         {
 176         printfd(__FILE__, "Failed to send RReqPDU: %s\n", strerror(errno));
 177         return false;
 178         }
 179     }
 180 return true;
 181 }
 182
 183 SMUX_PDUs_t * RecvSMUXPDUs(int fd)
 184 {
 185 char buffer[1024];
 186 SMUX_PDUs_t * pdus = NULL;
 187
 188 memset(buffer, 0, sizeof(buffer));
 189
 190 size_t length = read(fd, buffer, sizeof(buffer));
 191 if (length < 1)
 192     return NULL;
 193 asn_dec_rval_t error;
 194 error = ber_decode(0, &asn_DEF_SMUX_PDUs, (void **)&pdus, buffer, length);
 195
 196 if(error.code != RC_OK)
 197     {
 198     printfd(__FILE__, "Failed to decode PDUs at byte %ld\n",
 199             (long)error.consumed);
 200     return NULL;
 201     }
 202 return pdus;
 203 }
 204
 205 bool SendGetResponsePDU(int fd, GetResponse_PDU_t * getResponse)
 206 {
 207 asn_enc_rval_t error;
 208
 209 char buffer[1024];
 210 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, getResponse, buffer,
 211                              sizeof(buffer));
 212
 213 if (error.encoded == -1)
 214     {
 215     printfd(__FILE__, "Could not encode GetResponsePDU (at %s)\n",
 216             error.failed_type ? error.failed_type->name : "unknown");
 217     return false;
 218     }
 219 else
 220     {
 221     if (write(fd, buffer, error.encoded) < 0)
 222         {
 223         printfd(__FILE__, "Failed to send GetResponsePDU: %s\n", strerror(errno));
 224         return false;
 225         }
 226     }
 227 return true;
 228 }
 229
 230 bool SendGetResponseErrorPDU(int fd,
 231                              const PDU_t * getRequest,
 232                              int errorStatus,
 233                              int errorIndex)
 234 {
 235 asn_enc_rval_t error;
 236 GetResponse_PDU_t msg;
 237
 238 memset(&msg, 0, sizeof(msg));
 239
 240 long id = 0;
 241 asn_INTEGER2long(&getRequest->request_id, &id);
 242 asn_long2INTEGER(&msg.request_id, id);
 243 asn_long2INTEGER(&msg.error_status, errorStatus);
 244 asn_long2INTEGER(&msg.error_index, errorIndex);
 245
 246 char buffer[1024];
 247 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, &msg, buffer,
 248                              sizeof(buffer));
 249
 250 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_GetResponse_PDU, &msg);
 251
 252 if (error.encoded == -1)
 253     {
 254     printfd(__FILE__, "Could not encode GetResponsePDU for error (at %s)\n",
 255             error.failed_type ? error.failed_type->name : "unknown");
 256     return false;
 257     }
 258 else
 259     {
 260     if (write(fd, buffer, error.encoded) < 0)
 261         {
 262         printfd(__FILE__, "Failed to send GetResponseErrorPDU: %s\n", strerror(errno));
 263         return false;
 264         }
 265     }
 266 return true;
 267 }