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