]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/smux/utils.cpp
Regen SMUX support library with more recent ASN1 compiler.
[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 uint32_t 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, 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 uint32_t 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                            8);
139
140 char buffer[1024];
141 error = der_encode_to_buffer(&asn_DEF_RReqPDU, &msg, buffer, sizeof(buffer));
142
143 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_RReqPDU, &msg);
144
145 if (error.encoded == -1)
146     {
147     printfd(__FILE__, "Could not encode RReqPDU (at %s)\n",
148             error.failed_type ? error.failed_type->name : "unknown");
149     return false;
150     }
151 else
152     {
153     if (write(fd, buffer, error.encoded) < 0)
154         {
155         printfd(__FILE__, "Failed to send RReqPDU: %s\n", strerror(errno));
156         return false;
157         }
158     }
159 return true;
160 }
161
162 SMUX_PDUs_t * RecvSMUXPDUs(int fd)
163 {
164 char buffer[1024];
165 SMUX_PDUs_t * pdus = NULL;
166
167 memset(buffer, 0, sizeof(buffer));
168
169 size_t length = read(fd, buffer, sizeof(buffer));
170 if (length < 1)
171     return NULL;
172 asn_dec_rval_t error;
173 void* p = pdus;
174 error = ber_decode(0, &asn_DEF_SMUX_PDUs, &p, buffer, length);
175
176 if(error.code != RC_OK)
177     {
178     printfd(__FILE__, "Failed to decode PDUs at byte %ld\n",
179             static_cast<long>(error.consumed));
180     return NULL;
181     }
182 return pdus;
183 }
184
185 bool SendGetResponsePDU(int fd, GetResponse_PDU_t * getResponse)
186 {
187 asn_enc_rval_t error;
188
189 char buffer[1024];
190 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, getResponse, buffer,
191                              sizeof(buffer));
192
193 if (error.encoded == -1)
194     {
195     printfd(__FILE__, "Could not encode GetResponsePDU (at %s)\n",
196             error.failed_type ? error.failed_type->name : "unknown");
197     return false;
198     }
199 else
200     {
201     if (write(fd, buffer, error.encoded) < 0)
202         {
203         printfd(__FILE__, "Failed to send GetResponsePDU: %s\n", strerror(errno));
204         return false;
205         }
206     }
207 return true;
208 }
209
210 bool SendGetResponseErrorPDU(int fd,
211                              const PDU_t * getRequest,
212                              int errorStatus,
213                              int errorIndex)
214 {
215 asn_enc_rval_t error;
216 GetResponse_PDU_t msg;
217
218 memset(&msg, 0, sizeof(msg));
219
220 long id = 0;
221 asn_INTEGER2long(&getRequest->request_id, &id);
222 asn_long2INTEGER(&msg.request_id, id);
223 asn_long2INTEGER(&msg.error_status, errorStatus);
224 asn_long2INTEGER(&msg.error_index, errorIndex);
225
226 char buffer[1024];
227 error = der_encode_to_buffer(&asn_DEF_GetResponse_PDU, &msg, buffer,
228                              sizeof(buffer));
229
230 ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_GetResponse_PDU, &msg);
231
232 if (error.encoded == -1)
233     {
234     printfd(__FILE__, "Could not encode GetResponsePDU for error (at %s)\n",
235             error.failed_type ? error.failed_type->name : "unknown");
236     return false;
237     }
238 else
239     {
240     if (write(fd, buffer, error.encoded) < 0)
241         {
242         printfd(__FILE__, "Failed to send GetResponseErrorPDU: %s\n", strerror(errno));
243         return false;
244         }
245     }
246 return true;
247 }