minix/lib/liblwip/dist/src/netif/ppp/pppapi.c

   1 /**
   2  * @file
   3  * Point To Point Protocol Sequential API module
   4  *
   5  */
   6
   7 /*
   8  * Redistribution and use in source and binary forms, with or without modification,
   9  * are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright notice,
  12  *    this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14  *    this list of conditions and the following disclaimer in the documentation
  15  *    and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  20  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  22  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  24  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  28  * OF SUCH DAMAGE.
  29  *
  30  * This file is part of the lwIP TCP/IP stack.
  31  *
  32  */
  33
  34 #include "netif/ppp/ppp_opts.h"
  35
  36 #if LWIP_PPP_API /* don't build if not configured for use in lwipopts.h */
  37
  38 #include "netif/ppp/pppapi.h"
  39 #include "lwip/priv/tcpip_priv.h"
  40 #include "netif/ppp/pppoe.h"
  41 #include "netif/ppp/pppol2tp.h"
  42 #include "netif/ppp/pppos.h"
  43
  44 #if LWIP_MPU_COMPATIBLE
  45 LWIP_MEMPOOL_DECLARE(PPPAPI_MSG, MEMP_NUM_PPP_API_MSG, sizeof(struct pppapi_msg), "PPPAPI_MSG")
  46 #endif
  47
  48 #define PPPAPI_VAR_REF(name)               API_VAR_REF(name)
  49 #define PPPAPI_VAR_DECLARE(name)           API_VAR_DECLARE(struct pppapi_msg, name)
  50 #define PPPAPI_VAR_ALLOC(name)             API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, ERR_MEM)
  51 #define PPPAPI_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, NULL)
  52 #define PPPAPI_VAR_FREE(name)              API_VAR_FREE_POOL(PPPAPI_MSG, name)
  53
  54 /**
  55  * Call ppp_set_default() inside the tcpip_thread context.
  56  */
  57 static err_t
  58 pppapi_do_ppp_set_default(struct tcpip_api_call_data *m)
  59 {
  60   /* cast through void* to silence alignment warnings.
  61    * We know it works because the structs have been instantiated as struct pppapi_msg */
  62   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
  63
  64   ppp_set_default(msg->msg.ppp);
  65   return ERR_OK;
  66 }
  67
  68 /**
  69  * Call ppp_set_default() in a thread-safe way by running that function inside the
  70  * tcpip_thread context.
  71  */
  72 err_t
  73 pppapi_set_default(ppp_pcb *pcb)
  74 {
  75   err_t err;
  76   PPPAPI_VAR_DECLARE(msg);
  77   PPPAPI_VAR_ALLOC(msg);
  78
  79   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
  80   err = tcpip_api_call(pppapi_do_ppp_set_default, &PPPAPI_VAR_REF(msg).call);
  81   PPPAPI_VAR_FREE(msg);
  82   return err;
  83 }
  84
  85
  86 #if PPP_NOTIFY_PHASE
  87 /**
  88  * Call ppp_set_notify_phase_callback() inside the tcpip_thread context.
  89  */
  90 static err_t
  91 pppapi_do_ppp_set_notify_phase_callback(struct tcpip_api_call_data *m)
  92 {
  93   /* cast through void* to silence alignment warnings.
  94    * We know it works because the structs have been instantiated as struct pppapi_msg */
  95    struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
  96
  97   ppp_set_notify_phase_callback(msg->msg.ppp, msg->msg.msg.setnotifyphasecb.notify_phase_cb);
  98   return ERR_OK;
  99 }
 100
 101 /**
 102  * Call ppp_set_notify_phase_callback() in a thread-safe way by running that function inside the
 103  * tcpip_thread context.
 104  */
 105 err_t
 106 pppapi_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb)
 107 {
 108   err_t err;
 109   PPPAPI_VAR_DECLARE(msg);
 110   PPPAPI_VAR_ALLOC(msg);
 111
 112   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 113   PPPAPI_VAR_REF(msg).msg.msg.setnotifyphasecb.notify_phase_cb = notify_phase_cb;
 114   err = tcpip_api_call(pppapi_do_ppp_set_notify_phase_callback, &PPPAPI_VAR_REF(msg).call);
 115   PPPAPI_VAR_FREE(msg);
 116   return err;
 117 }
 118 #endif /* PPP_NOTIFY_PHASE */
 119
 120
 121 #if PPPOS_SUPPORT
 122 /**
 123  * Call pppos_create() inside the tcpip_thread context.
 124  */
 125 static err_t
 126 pppapi_do_pppos_create(struct tcpip_api_call_data *m)
 127 {
 128   /* cast through void* to silence alignment warnings.
 129    * We know it works because the structs have been instantiated as struct pppapi_msg */
 130   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 131
 132   msg->msg.ppp = pppos_create(msg->msg.msg.serialcreate.pppif, msg->msg.msg.serialcreate.output_cb,
 133     msg->msg.msg.serialcreate.link_status_cb, msg->msg.msg.serialcreate.ctx_cb);
 134   return ERR_OK;
 135 }
 136
 137 /**
 138  * Call pppos_create() in a thread-safe way by running that function inside the
 139  * tcpip_thread context.
 140  */
 141 ppp_pcb*
 142 pppapi_pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb,
 143                ppp_link_status_cb_fn link_status_cb, void *ctx_cb)
 144 {
 145   ppp_pcb* result;
 146   PPPAPI_VAR_DECLARE(msg);
 147   PPPAPI_VAR_ALLOC_RETURN_NULL(msg);
 148
 149   PPPAPI_VAR_REF(msg).msg.ppp = NULL;
 150   PPPAPI_VAR_REF(msg).msg.msg.serialcreate.pppif = pppif;
 151   PPPAPI_VAR_REF(msg).msg.msg.serialcreate.output_cb = output_cb;
 152   PPPAPI_VAR_REF(msg).msg.msg.serialcreate.link_status_cb = link_status_cb;
 153   PPPAPI_VAR_REF(msg).msg.msg.serialcreate.ctx_cb = ctx_cb;
 154   tcpip_api_call(pppapi_do_pppos_create, &PPPAPI_VAR_REF(msg).call);
 155   result = PPPAPI_VAR_REF(msg).msg.ppp;
 156   PPPAPI_VAR_FREE(msg);
 157   return result;
 158 }
 159 #endif /* PPPOS_SUPPORT */
 160
 161
 162 #if PPPOE_SUPPORT
 163 /**
 164  * Call pppoe_create() inside the tcpip_thread context.
 165  */
 166 static err_t
 167 pppapi_do_pppoe_create(struct tcpip_api_call_data *m)
 168 {
 169   /* cast through void* to silence alignment warnings.
 170    * We know it works because the structs have been instantiated as struct pppapi_msg */
 171   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 172
 173   msg->msg.ppp = pppoe_create(msg->msg.msg.ethernetcreate.pppif, msg->msg.msg.ethernetcreate.ethif,
 174     msg->msg.msg.ethernetcreate.service_name, msg->msg.msg.ethernetcreate.concentrator_name,
 175     msg->msg.msg.ethernetcreate.link_status_cb, msg->msg.msg.ethernetcreate.ctx_cb);
 176   return ERR_OK;
 177 }
 178
 179 /**
 180  * Call pppoe_create() in a thread-safe way by running that function inside the
 181  * tcpip_thread context.
 182  */
 183 ppp_pcb*
 184 pppapi_pppoe_create(struct netif *pppif, struct netif *ethif, const char *service_name,
 185                             const char *concentrator_name, ppp_link_status_cb_fn link_status_cb,
 186                             void *ctx_cb)
 187 {
 188   ppp_pcb* result;
 189   PPPAPI_VAR_DECLARE(msg);
 190   PPPAPI_VAR_ALLOC_RETURN_NULL(msg);
 191
 192   PPPAPI_VAR_REF(msg).msg.ppp = NULL;
 193   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.pppif = pppif;
 194   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ethif = ethif;
 195   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.service_name = service_name;
 196   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.concentrator_name = concentrator_name;
 197   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.link_status_cb = link_status_cb;
 198   PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ctx_cb = ctx_cb;
 199   tcpip_api_call(pppapi_do_pppoe_create, &PPPAPI_VAR_REF(msg).call);
 200   result = PPPAPI_VAR_REF(msg).msg.ppp;
 201   PPPAPI_VAR_FREE(msg);
 202   return result;
 203 }
 204 #endif /* PPPOE_SUPPORT */
 205
 206
 207 #if PPPOL2TP_SUPPORT
 208 /**
 209  * Call pppol2tp_create() inside the tcpip_thread context.
 210  */
 211 static err_t
 212 pppapi_do_pppol2tp_create(struct tcpip_api_call_data *m)
 213 {
 214   /* cast through void* to silence alignment warnings.
 215    * We know it works because the structs have been instantiated as struct pppapi_msg */
 216   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 217
 218   msg->msg.ppp = pppol2tp_create(msg->msg.msg.l2tpcreate.pppif,
 219     msg->msg.msg.l2tpcreate.netif, API_EXPR_REF(msg->msg.msg.l2tpcreate.ipaddr), msg->msg.msg.l2tpcreate.port,
 220 #if PPPOL2TP_AUTH_SUPPORT
 221     msg->msg.msg.l2tpcreate.secret,
 222     msg->msg.msg.l2tpcreate.secret_len,
 223 #else /* PPPOL2TP_AUTH_SUPPORT */
 224     NULL,
 225     0,
 226 #endif /* PPPOL2TP_AUTH_SUPPORT */
 227     msg->msg.msg.l2tpcreate.link_status_cb, msg->msg.msg.l2tpcreate.ctx_cb);
 228   return ERR_OK;
 229 }
 230
 231 /**
 232  * Call pppol2tp_create() in a thread-safe way by running that function inside the
 233  * tcpip_thread context.
 234  */
 235 ppp_pcb*
 236 pppapi_pppol2tp_create(struct netif *pppif, struct netif *netif, ip_addr_t *ipaddr, u16_t port,
 237                         const u8_t *secret, u8_t secret_len,
 238                         ppp_link_status_cb_fn link_status_cb, void *ctx_cb)
 239 {
 240   ppp_pcb* result;
 241   PPPAPI_VAR_DECLARE(msg);
 242   PPPAPI_VAR_ALLOC_RETURN_NULL(msg);
 243 #if !PPPOL2TP_AUTH_SUPPORT
 244   LWIP_UNUSED_ARG(secret);
 245   LWIP_UNUSED_ARG(secret_len);
 246 #endif /* !PPPOL2TP_AUTH_SUPPORT */
 247
 248   PPPAPI_VAR_REF(msg).msg.ppp = NULL;
 249   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.pppif = pppif;
 250   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.netif = netif;
 251   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ipaddr = PPPAPI_VAR_REF(ipaddr);
 252   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.port = port;
 253 #if PPPOL2TP_AUTH_SUPPORT
 254   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret = secret;
 255   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret_len = secret_len;
 256 #endif /* PPPOL2TP_AUTH_SUPPORT */
 257   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.link_status_cb = link_status_cb;
 258   PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ctx_cb = ctx_cb;
 259   tcpip_api_call(pppapi_do_pppol2tp_create, &PPPAPI_VAR_REF(msg).call);
 260   result = PPPAPI_VAR_REF(msg).msg.ppp;
 261   PPPAPI_VAR_FREE(msg);
 262   return result;
 263 }
 264 #endif /* PPPOL2TP_SUPPORT */
 265
 266
 267 /**
 268  * Call ppp_connect() inside the tcpip_thread context.
 269  */
 270 static err_t
 271 pppapi_do_ppp_connect(struct tcpip_api_call_data *m)
 272 {
 273   /* cast through void* to silence alignment warnings.
 274    * We know it works because the structs have been instantiated as struct pppapi_msg */
 275   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 276
 277   return ppp_connect(msg->msg.ppp, msg->msg.msg.connect.holdoff);
 278 }
 279
 280 /**
 281  * Call ppp_connect() in a thread-safe way by running that function inside the
 282  * tcpip_thread context.
 283  */
 284 err_t
 285 pppapi_connect(ppp_pcb *pcb, u16_t holdoff)
 286 {
 287   err_t err;
 288   PPPAPI_VAR_DECLARE(msg);
 289   PPPAPI_VAR_ALLOC(msg);
 290
 291   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 292   PPPAPI_VAR_REF(msg).msg.msg.connect.holdoff = holdoff;
 293   err = tcpip_api_call(pppapi_do_ppp_connect, &PPPAPI_VAR_REF(msg).call);
 294   PPPAPI_VAR_FREE(msg);
 295   return err;
 296 }
 297
 298
 299 #if PPP_SERVER
 300 /**
 301  * Call ppp_listen() inside the tcpip_thread context.
 302  */
 303 static err_t
 304 pppapi_do_ppp_listen(struct tcpip_api_call_data *m)
 305 {
 306   /* cast through void* to silence alignment warnings.
 307    * We know it works because the structs have been instantiated as struct pppapi_msg */
 308   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 309
 310   return ppp_listen(msg->msg.ppp);
 311 }
 312
 313 /**
 314  * Call ppp_listen() in a thread-safe way by running that function inside the
 315  * tcpip_thread context.
 316  */
 317 err_t
 318 pppapi_listen(ppp_pcb *pcb)
 319 {
 320   err_t err;
 321   PPPAPI_VAR_DECLARE(msg);
 322   PPPAPI_VAR_ALLOC(msg);
 323
 324   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 325   err = tcpip_api_call(pppapi_do_ppp_listen, &PPPAPI_VAR_REF(msg).call);
 326   PPPAPI_VAR_FREE(msg);
 327   return err;
 328 }
 329 #endif /* PPP_SERVER */
 330
 331
 332 /**
 333  * Call ppp_close() inside the tcpip_thread context.
 334  */
 335 static err_t
 336 pppapi_do_ppp_close(struct tcpip_api_call_data *m)
 337 {
 338   /* cast through void* to silence alignment warnings.
 339    * We know it works because the structs have been instantiated as struct pppapi_msg */
 340   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 341
 342   return ppp_close(msg->msg.ppp, msg->msg.msg.close.nocarrier);
 343 }
 344
 345 /**
 346  * Call ppp_close() in a thread-safe way by running that function inside the
 347  * tcpip_thread context.
 348  */
 349 err_t
 350 pppapi_close(ppp_pcb *pcb, u8_t nocarrier)
 351 {
 352   err_t err;
 353   PPPAPI_VAR_DECLARE(msg);
 354   PPPAPI_VAR_ALLOC(msg);
 355
 356   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 357   PPPAPI_VAR_REF(msg).msg.msg.close.nocarrier = nocarrier;
 358   err = tcpip_api_call(pppapi_do_ppp_close, &PPPAPI_VAR_REF(msg).call);
 359   PPPAPI_VAR_FREE(msg);
 360   return err;
 361 }
 362
 363
 364 /**
 365  * Call ppp_free() inside the tcpip_thread context.
 366  */
 367 static err_t
 368 pppapi_do_ppp_free(struct tcpip_api_call_data *m)
 369 {
 370   /* cast through void* to silence alignment warnings.
 371    * We know it works because the structs have been instantiated as struct pppapi_msg */
 372   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 373
 374   return ppp_free(msg->msg.ppp);
 375 }
 376
 377 /**
 378  * Call ppp_free() in a thread-safe way by running that function inside the
 379  * tcpip_thread context.
 380  */
 381 err_t
 382 pppapi_free(ppp_pcb *pcb)
 383 {
 384   err_t err;
 385   PPPAPI_VAR_DECLARE(msg);
 386   PPPAPI_VAR_ALLOC(msg);
 387
 388   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 389   err = tcpip_api_call(pppapi_do_ppp_free, &PPPAPI_VAR_REF(msg).call);
 390   PPPAPI_VAR_FREE(msg);
 391   return err;
 392 }
 393
 394
 395 /**
 396  * Call ppp_ioctl() inside the tcpip_thread context.
 397  */
 398 static err_t
 399 pppapi_do_ppp_ioctl(struct tcpip_api_call_data *m)
 400 {
 401   /* cast through void* to silence alignment warnings.
 402    * We know it works because the structs have been instantiated as struct pppapi_msg */
 403   struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m;
 404
 405   return ppp_ioctl(msg->msg.ppp, msg->msg.msg.ioctl.cmd, msg->msg.msg.ioctl.arg);
 406 }
 407
 408 /**
 409  * Call ppp_ioctl() in a thread-safe way by running that function inside the
 410  * tcpip_thread context.
 411  */
 412 err_t
 413 pppapi_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg)
 414 {
 415   err_t err;
 416   PPPAPI_VAR_DECLARE(msg);
 417   PPPAPI_VAR_ALLOC(msg);
 418
 419   PPPAPI_VAR_REF(msg).msg.ppp = pcb;
 420   PPPAPI_VAR_REF(msg).msg.msg.ioctl.cmd = cmd;
 421   PPPAPI_VAR_REF(msg).msg.msg.ioctl.arg = arg;
 422   err = tcpip_api_call(pppapi_do_ppp_ioctl, &PPPAPI_VAR_REF(msg).call);
 423   PPPAPI_VAR_FREE(msg);
 424   return err;
 425 }
 426
 427 #endif /* LWIP_PPP_API */