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