Fawkes API  Fawkes Development Version
mod_protobuf.cpp
1 
2 /***************************************************************************
3  * mod_protobuf.cpp - OpenPRS protobuf communication module
4  *
5  * Created: Tue Sep 02 16:23:43 2014
6  * Copyright 2014 Tim Niemueller [www.niemueller.de]
7  ****************************************************************************/
8 
9 /* This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Library General Public License for more details.
18  *
19  * Read the full text in the LICENSE.GPL file in the doc directory.
20  */
21 
22 #include <plugins/openprs/mod_utils.h>
23 #include "oprs_protobuf.h"
24 
25 #include <core/exception.h>
26 
27 #include <oprs-type_f-pub.h>
28 #include <oprs-array_f-pub.h>
29 #include <oprs_f-pub.h>
30 #include <slistPack_f.h>
31 #include <lisp-list_f-pub.h>
32 
33 using namespace oprs_protobuf;
34 
35 extern "C" void finalize();
36 
37 #define ASSERT_PB \
38  do { \
39  if (! g_oprs_pb) { \
40  fprintf(stderr, "Error: pb-setup has not been called\n"); \
41  ACTION_FAIL(); \
42  } \
43  } while (0);
44 
45 #define ASSERT_B_PB \
46  do { \
47  if (! g_oprs_pb) { \
48  fprintf(stderr, "Error: pb-setup has not been called\n"); \
49  return true; \
50  } \
51  } while (0);
52 
53 
54 // Global variables
55 OpenPRSProtobuf *g_oprs_pb = NULL;
56 
57 extern "C"
58 Term *
59 action_pb_setup(TermList terms)
60 {
61  int terms_len = sl_slist_length(terms);
62  if (terms_len != 1) {
63  fprintf(stderr, "Error[pb-setup]: invalid number of "
64  "arguments: req 1, got %i\n", terms_len);
65  ACTION_FAIL();
66  }
67 
68  Term *proto_paths = (Term *)get_list_pos(terms, 1);
69  if (proto_paths->type != LISP_LIST) {
70  fprintf(stderr, "Error[pb-setup]: proto paths type is not a LISP_LIST\n");
71  ACTION_FAIL();
72  }
73 
74  size_t num_paths = 0;
75  for (L_List p_l = proto_paths->u.l_list; p_l; p_l = l_cdr(p_l)) {
76  Term *t = l_car(p_l);
77  if (t->type != STRING) {
78  fprintf(stderr, "Error[pb-setup]: at least one proto path is not of type STRING\n");
79  ACTION_FAIL();
80  }
81  num_paths += 1;
82  }
83 
84  std::vector<std::string> ppaths(num_paths);
85  size_t i = 0;
86  for (L_List p_l = proto_paths->u.l_list; p_l; p_l = l_cdr(p_l)) {
87  Term *t = l_car(p_l);
88  ppaths[i++] = t->u.string;
89  }
90 
91  for (size_t i = 0; i < ppaths.size(); ++i) {
92  std::string::size_type pos;
93  if ((pos = ppaths[i].find("@BASEDIR@")) != std::string::npos) {
94  ppaths[i].replace(pos, 9, BASEDIR);
95  }
96  if ((pos = ppaths[i].find("@FAWKES_BASEDIR@")) != std::string::npos) {
97  ppaths[i].replace(pos, 16, FAWKES_BASEDIR);
98  }
99  if ((pos = ppaths[i].find("@RESDIR@")) != std::string::npos) {
100  ppaths[i].replace(pos, 8, RESDIR);
101  }
102  if ((pos = ppaths[i].find("@CONFDIR@")) != std::string::npos) {
103  ppaths[i].replace(pos, 9, CONFDIR);
104  }
105  if (ppaths[i][ppaths.size()-1] != '/') {
106  ppaths[i] += "/";
107  }
108  }
109 
110  delete g_oprs_pb;
111  g_oprs_pb = new OpenPRSProtobuf(ppaths);
112 
113  ACTION_FINAL();
114 }
115 
116 
117 extern "C"
118 Term *
119 func_pb_create(TermList terms)
120 {
121  ASSERT_PB;
122 
123  Term *type;
124 
125  ACTION_ASSERT_ARG_LENGTH("pb-create", terms, 1);
126  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-create", type, terms, 1, STRING);
127 
128 
129  try {
130  std::shared_ptr<google::protobuf::Message> *msg =
131  g_oprs_pb->oprs_create_msg(type->u.string);
132 
133  Term *res = MAKE_OBJECT(Term);
134  res->type = U_POINTER;
135  res->u.u_pointer = msg;
136  return res;
137  } catch (std::runtime_error &e) {
138  fprintf(stderr, "Cannot create message of type %s: %s", type->u.string, e.what());
139  return build_nil();
140  }
141 }
142 
143 
144 extern "C"
145 Term *
146 action_pb_client_connect(TermList terms)
147 {
148  ASSERT_PB;
149 
150  Term *host, *port;
151  ACTION_ASSERT_ARG_LENGTH("pb-client-connect", terms, 2);
152  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-client-connect", host, terms, 1, STRING);
153  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-client-connect", port, terms, 2, LONG_LONG);
154 
155  if (port->u.llintval < 0 || port->u.llintval > 65535) {
156  fprintf(stderr, "Error[pb-client-connect]: invalid port %lli\n", port->u.llintval);
157  ACTION_FAIL();
158  }
159 
160  return g_oprs_pb->oprs_pb_client_connect(host->u.string, port->u.llintval);
161 }
162 
163 
164 extern "C"
165 Term *
166 action_pb_enable_server(TermList terms)
167 {
168  ASSERT_PB;
169 
170  Term *port;
171  ACTION_ASSERT_ARG_LENGTH("pb-enable-server", terms, 1);
172  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-enable-server", port, terms, 1, LONG_LONG);
173 
174  if (port->u.llintval < 0 || port->u.llintval > 65535) {
175  fprintf(stderr, "Error[pb-enable-server]: invalid port %lli\n", port->u.llintval);
176  ACTION_FAIL();
177  }
178 
179  try {
180  g_oprs_pb->oprs_pb_enable_server(port->u.llintval);
181  ACTION_FINAL();
182  } catch (fawkes::Exception &e) {
183  fprintf(stderr, "Error[pb-enable-server]: %s\n", e.what_no_backtrace());
184  ACTION_FAIL();
185  }
186 }
187 
188 
189 extern "C"
190 Term *
191 action_pb_disable_server(TermList terms)
192 {
193  ASSERT_PB;
194 
195  ACTION_ASSERT_ARG_LENGTH("pb-disable-server", terms, 0);
196 
197  try {
198  g_oprs_pb->oprs_pb_disable_server();
199  ACTION_FINAL();
200  } catch (fawkes::Exception &e) {
201  fprintf(stderr, "Error[pb-disable-server]: %s\n", e.what_no_backtrace());
202  ACTION_FAIL();
203  }
204 }
205 
206 
207 extern "C"
208 Term *
209 action_pb_peer_create(TermList terms)
210 {
211  ASSERT_PB;
212 
213  Term *host, *port;
214  ACTION_ASSERT_ARG_LENGTH("pb-peer-create", terms, 2);
215  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create", host, terms, 1, STRING);
216  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create", port, terms, 2, LONG_LONG);
217 
218  if (port->u.llintval < 0 || port->u.llintval > 65535) {
219  fprintf(stderr, "Error[pb-peer-create]: invalid port %lli\n", port->u.llintval);
220  ACTION_FAIL();
221  }
222 
223  return g_oprs_pb->oprs_pb_peer_create(host->u.string, port->u.llintval);
224 }
225 
226 
227 extern "C"
228 Term *
229 action_pb_peer_create_local(TermList terms)
230 {
231  ASSERT_PB;
232 
233  Term *host, *send_port, *recv_port;
234  ACTION_ASSERT_ARG_LENGTH("pb-peer-create-local", terms, 3);
235  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local", host, terms, 1, STRING);
236  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local", send_port, terms, 2, LONG_LONG);
237  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local", recv_port, terms, 3, LONG_LONG);
238 
239  if (send_port->u.llintval < 0 || send_port->u.llintval > 65535) {
240  fprintf(stderr, "Error[pb-peer-create-local]: invalid send port %lli\n", send_port->u.llintval);
241  ACTION_FAIL();
242  }
243  if (recv_port->u.llintval < 0 || recv_port->u.llintval > 65535) {
244  fprintf(stderr, "Error[pb-peer-create-local]: invalid recv port %lli\n", recv_port->u.llintval);
245  ACTION_FAIL();
246  }
247 
248  return g_oprs_pb->oprs_pb_peer_create_local(host->u.string,
249  send_port->u.llintval, recv_port->u.llintval);
250 }
251 
252 
253 extern "C"
254 Term *
255 action_pb_peer_create_crypto(TermList terms)
256 {
257  ASSERT_PB;
258 
259  Term *host, *port, *crypto_key, *cipher;
260  ACTION_ASSERT_ARG_LENGTH("pb-peer-create-local", terms, 4);
261  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-crypto", host, terms, 1, STRING);
262  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-crypto", port, terms, 2, LONG_LONG);
263  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-crypto", crypto_key, terms, 3, STRING);
264  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-crypto", cipher, terms, 4, STRING);
265 
266  if (port->u.llintval < 0 || port->u.llintval > 65535) {
267  fprintf(stderr, "Error[pb-peer-create-local]: invalid port %lli\n", port->u.llintval);
268  ACTION_FAIL();
269  }
270 
271  return g_oprs_pb->oprs_pb_peer_create_crypto(host->u.string, port->u.llintval,
272  crypto_key->u.string, cipher->u.string);
273 }
274 
275 
276 extern "C"
277 Term *
278 action_pb_peer_create_local_crypto(TermList terms)
279 {
280  ASSERT_PB;
281 
282  Term *host, *send_port, *recv_port, *crypto_key, *cipher;
283  ACTION_ASSERT_ARG_LENGTH("pb-peer-create-local-crypto", terms, 5);
284  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local-crypto", host, terms, 1, STRING);
285  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local-crypto", send_port, terms, 2, LONG_LONG);
286  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local-crypto", recv_port, terms, 3, LONG_LONG);
287  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local-crypto", crypto_key, terms, 4, STRING);
288  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-create-local-crypto", cipher, terms, 5, STRING);
289 
290  if (send_port->u.llintval < 0 || send_port->u.llintval > 65535) {
291  fprintf(stderr, "Error[pb-peer-create-local]: invalid send port %lli\n", send_port->u.llintval);
292  ACTION_FAIL();
293  }
294  if (recv_port->u.llintval < 0 || recv_port->u.llintval > 65535) {
295  fprintf(stderr, "Error[pb-peer-create-local]: invalid recv port %lli\n", recv_port->u.llintval);
296  ACTION_FAIL();
297  }
298 
299  printf("Creating local peer. %s:%lli %lli %s %s\n",
300  host->u.string, send_port->u.llintval, recv_port->u.llintval, crypto_key->u.string, cipher->u.string);
301  return g_oprs_pb->oprs_pb_peer_create_local_crypto(host->u.string, send_port->u.llintval,
302  recv_port->u.llintval,
303  crypto_key->u.string, cipher->u.string);
304 }
305 
306 
307 extern "C"
308 Term *
309 action_pb_peer_setup_crypto(TermList terms)
310 {
311  ASSERT_PB;
312 
313  Term *peer_id, *crypto_key, *cipher;
314  ACTION_ASSERT_ARG_LENGTH("pb-peer-setup-crypto", terms, 4);
315  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-setup-crypto", peer_id, terms, 1, LONG_LONG);
316  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-setup-crypto", crypto_key, terms, 2, STRING);
317  ACTION_SET_AND_ASSERT_ARG_TYPE("pb-peer-setup-crypto", cipher, terms, 3, STRING);
318 
319  try {
320  g_oprs_pb->oprs_pb_peer_setup_crypto(peer_id->u.llintval,
321  crypto_key->u.string, cipher->u.string);
322  ACTION_FINAL();
323  } catch (fawkes::Exception &e) {
324  fprintf(stderr, "Error[pb-peer-setup-crypto]: %s\n", e.what_no_backtrace());
325  ACTION_FAIL();
326  }
327 }
328 
329 
330 extern "C"
331 PBoolean
332 pred_pb_events_pending(TermList terms)
333 {
334  ASSERT_B_PB;
335 
336  return g_oprs_pb->oprs_pb_events_pending();
337 }
338 
339 
340 extern "C"
341 Term *
342 action_pb_process(TermList terms)
343 {
344  ASSERT_PB;
345 
346  try {
347  g_oprs_pb->oprs_pb_process();
348  ACTION_FINAL();
349  } catch (fawkes::Exception &e) {
350  fprintf(stderr, "Error[pb-process]: %s\n", e.what_no_backtrace());
351  ACTION_FAIL();
352  }
353 }
354 
355 
356 #define PB_FIELD_ACCESSOR_FUNC(func_name, print_name) \
357  extern "C" \
358  Term * \
359  func_pb_ ## func_name (TermList terms) \
360  { \
361  ASSERT_PB; \
362  \
363  Term *msg, *field_name; \
364  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 2); \
365  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, msg, terms, 1, U_POINTER); \
366  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, field_name, terms, 2, STRING); \
367  \
368  return g_oprs_pb->oprs_pb_## func_name (msg->u.u_pointer, field_name->u.string); \
369  }
370 
371 #define PB_FIELD_ACCESSOR_PRED(func_name, print_name) \
372  extern "C" \
373  PBoolean \
374  pred_pb_ ## func_name (TermList terms) \
375  { \
376  ASSERT_B_PB; \
377  \
378  Term *msg, *field_name; \
379  ACTION_ASSERT_B_ARG_LENGTH(print_name, terms, 2); \
380  ACTION_SET_AND_ASSERT_B_ARG_TYPE(print_name, msg, terms, 1, U_POINTER); \
381  ACTION_SET_AND_ASSERT_B_ARG_TYPE(print_name, field_name, terms, 2, STRING); \
382  \
383  return g_oprs_pb->oprs_pb_ ## func_name (msg->u.u_pointer, field_name->u.string); \
384  }
385 
386 
387 #define PB_MESSAGE_FUNC(func_name, print_name) \
388  extern "C" \
389  Term * \
390  func_pb_ ## func_name (TermList terms) \
391  { \
392  ASSERT_PB; \
393  \
394  Term *msg; \
395  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 1); \
396  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, msg, terms, 1, U_POINTER); \
397  \
398  return g_oprs_pb->oprs_pb_ ## func_name (msg->u.u_pointer); \
399  }
400 
401 #define PB_MESSAGE_ACTION(func_name, print_name) \
402  extern "C" \
403  Term * \
404  action_pb_ ## func_name (TermList terms) \
405  { \
406  ASSERT_PB; \
407  \
408  Term *msg; \
409  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 1); \
410  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, msg, terms, 1, U_POINTER); \
411  \
412  return g_oprs_pb->oprs_pb_ ## func_name (msg->u.u_pointer); \
413  }
414 
415 #define PB_CLIENT_MESSAGE_ACTION(func_name, print_name) \
416  extern "C" \
417  Term * \
418  action_pb_ ## func_name (TermList terms) \
419  { \
420  ASSERT_PB; \
421  \
422  Term *client_id, *msg; \
423  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 2); \
424  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, client_id, terms, 1, LONG_LONG); \
425  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, msg, terms, 2, U_POINTER); \
426  \
427  try { \
428  g_oprs_pb->oprs_pb_ ## func_name (client_id->u.llintval, \
429  msg->u.u_pointer); \
430  ACTION_FINAL(); \
431  } catch (fawkes::Exception &e) { \
432  fprintf(stderr, "Error[%s]: %s\n", print_name, e.what_no_backtrace()); \
433  ACTION_FAIL(); \
434  } \
435  }
436 
437 #define PB_FIELD_SET_ACTION(func_name, print_name) \
438  extern "C" \
439  Term * \
440  action_pb_ ## func_name (TermList terms) \
441  { \
442  ASSERT_PB; \
443  \
444  Term *msg, *field_name, *value; \
445  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 3); \
446  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, msg, terms, 1, U_POINTER); \
447  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, field_name, terms, 2, STRING); \
448  value = (Term *)get_list_pos(terms, 3); \
449  \
450  try { \
451  g_oprs_pb->oprs_pb_## func_name (msg->u.u_pointer, field_name->u.string, value); \
452  ACTION_FINAL(); \
453  } catch (fawkes::Exception &e) { \
454  fprintf(stderr, "Error[%s]: %s\n", print_name, e.what_no_backtrace()); \
455  ACTION_FAIL(); \
456  } \
457  }
458 
459 #define PB_CLIENT_ID_ACTION(func_name, print_name) \
460  extern "C" \
461  Term * \
462  action_pb_ ## func_name (TermList terms) \
463  { \
464  ASSERT_PB; \
465  \
466  Term *client_id; \
467  ACTION_ASSERT_ARG_LENGTH(print_name, terms, 1); \
468  ACTION_SET_AND_ASSERT_ARG_TYPE(print_name, client_id, terms, 1, LONG_LONG); \
469  \
470  try { \
471  g_oprs_pb->oprs_pb_ ## func_name (client_id->u.llintval); \
472  ACTION_FINAL(); \
473  } catch (fawkes::Exception &e) { \
474  fprintf(stderr, "Error[pb-client-connect]: failed on " \
475  "client %lli\n", client_id->u.llintval); \
476  ACTION_FAIL(); \
477  } \
478  }
479 
480 PB_FIELD_ACCESSOR_FUNC(field_value, "pb-field-value")
481 PB_FIELD_ACCESSOR_FUNC(field_type, "pb-field-type")
482 PB_FIELD_ACCESSOR_FUNC(field_label, "pb-field-label")
483 PB_FIELD_ACCESSOR_FUNC(field_list, "pb-field-list")
484 
485 PB_FIELD_ACCESSOR_PRED(has_field, "pb-has-field")
486 PB_FIELD_ACCESSOR_PRED(field_is_list, "pb-field-is-list")
487 
488 PB_MESSAGE_FUNC(field_names, "pb-field-names")
489 PB_MESSAGE_FUNC(ref, "pb-ref")
490 PB_MESSAGE_ACTION(destroy, "pb-destroy")
491 PB_CLIENT_MESSAGE_ACTION(send, "pb-send")
492 PB_CLIENT_MESSAGE_ACTION(broadcast, "pb-broadcast")
493 
494 PB_FIELD_SET_ACTION(set_field, "pb-set-field")
495 PB_FIELD_SET_ACTION(add_list, "pb-add-list")
496 
497 PB_CLIENT_ID_ACTION(disconnect, "pb-disconnect")
498 PB_CLIENT_ID_ACTION(peer_destroy, "pb-peer-destroy")
499 
500 
501 /** Entry function for the OpenPRS module. */
502 extern "C"
503 void init()
504 {
505  printf("*** LOADING mod_protobuf\n");
506  printf("Make sure your kernel calls pb-setup!\n");
507 
508  make_and_declare_action("pb-setup", action_pb_setup, 1);
509  make_and_declare_action("pb-process", action_pb_process, 0);
510  make_and_declare_action("pb-destroy", action_pb_destroy, 1);
511  make_and_declare_action("pb-set-field", action_pb_set_field, 3);
512  make_and_declare_action("pb-add-list", action_pb_add_list, 3);
513  make_and_declare_action("pb-disconnect", action_pb_disconnect, 1);
514  make_and_declare_action("pb-peer-destroy", action_pb_peer_destroy, 1);
515  make_and_declare_action("pb-send", action_pb_send, 2);
516  make_and_declare_action("pb-broadcast", action_pb_broadcast, 2);
517  make_and_declare_action("pb-client-connect", action_pb_client_connect, 2);
518  make_and_declare_action("pb-enable-server", action_pb_enable_server, 1);
519  make_and_declare_action("pb-disable-server", action_pb_enable_server, 1);
520  make_and_declare_action("pb-peer-create", action_pb_peer_create, 2);
521  make_and_declare_action("pb-peer-create-local", action_pb_peer_create_local, 3);
522  make_and_declare_action("pb-peer-create-crypto", action_pb_peer_create_crypto, 4);
523  make_and_declare_action("pb-peer-create-local-crypto", action_pb_peer_create_local_crypto, 5);
524  make_and_declare_action("pb-peer-setup-crypto", action_pb_peer_setup_crypto, 3);
525 
526  make_and_declare_eval_funct("pb-create", func_pb_create, 1);
527  make_and_declare_eval_funct("pb-field-names", func_pb_field_names, 1);
528  make_and_declare_eval_funct("pb-ref", func_pb_ref, 1);
529  make_and_declare_eval_funct("pb-field-value", func_pb_field_value, 2);
530  make_and_declare_eval_funct("pb-field-type", func_pb_field_type, 2);
531  make_and_declare_eval_funct("pb-field-label", func_pb_field_label, 2);
532  make_and_declare_eval_funct("pb-field-list", func_pb_field_list, 2);
533 
534  make_and_declare_eval_pred("pb-has-field", pred_pb_has_field, 2, TRUE);
535  make_and_declare_eval_pred("pb-is-list", pred_pb_field_is_list, 2, TRUE);
536  make_and_declare_eval_pred("pb-events-pending", pred_pb_events_pending, 0, TRUE);
537 
538  add_user_end_kernel_hook(finalize);
539 }
540 
541 /** Finalization function for the OpenPRS module. */
542 extern "C"
543 void finalize()
544 {
545  printf("*** DESTROYING mod_protobuf\n");
546  delete g_oprs_pb;
547  g_oprs_pb = NULL;
548 }
std::shared_ptr< google::protobuf::Message > * oprs_create_msg(std::string full_name)
Create a new message of given type.
OpenPRS protobuf integration class.
Definition: oprs_protobuf.h:60
Term * oprs_pb_peer_create(std::string host, int port)
Enable protobuf peer.
void oprs_pb_process()
Process all pending events.
Term * oprs_pb_client_connect(std::string host, int port)
Connect as a client to the given server.
Term * oprs_pb_peer_create_crypto(std::string host, int port, std::string crypto_key="", std::string cipher="")
Enable protobuf peer.
void oprs_pb_enable_server(int port)
Enable protobuf stream server.
Term * oprs_pb_peer_create_local_crypto(std::string host, int send_port, int recv_port, std::string crypto_key="", std::string cipher="")
Enable protobuf peer.
Base class for exceptions in Fawkes.
Definition: exception.h:36
virtual const char * what_no_backtrace() const
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:686
Term * oprs_pb_peer_create_local(std::string host, int send_port, int recv_port)
Enable protobuf peer.
void oprs_pb_disable_server()
Disable protobuf stream server.
bool oprs_pb_events_pending()
Check if there are pending events.
void oprs_pb_peer_setup_crypto(long int peer_id, std::string crypto_key, std::string cipher)
Setup crypto for peer.