ceph/src/spdk/lib/sock/vpp/vpp.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) Intel Corporation.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "spdk/stdinc.h"
  35
  36 #include "spdk/log.h"
  37 #include "spdk/sock.h"
  38 #include "spdk/net.h"
  39 #include "spdk/string.h"
  40 #include "spdk_internal/sock.h"
  41 #include <vcl/vppcom.h>
  42
  43 #define MAX_TMPBUF 1024
  44 #define PORTNUMLEN 32
  45
  46 static bool g_vpp_initialized = false;
  47
  48 struct spdk_vpp_sock {
  49         struct spdk_sock        base;
  50         int                     fd;
  51 };
  52
  53 struct spdk_vpp_sock_group_impl {
  54         struct spdk_sock_group_impl     base;
  55         int                             fd;
  56 };
  57
  58 static int
  59 get_addr_str(struct sockaddr *sa, char *host, size_t hlen)
  60 {
  61         const char *result = NULL;
  62
  63         if (sa == NULL || host == NULL) {
  64                 return -1;
  65         }
  66
  67         if (sa->sa_family == AF_INET) {
  68                 result = inet_ntop(AF_INET, &(((struct sockaddr_in *)sa)->sin_addr),
  69                                    host, hlen);
  70         } else {
  71                 result = inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)sa)->sin6_addr),
  72                                    host, hlen);
  73         }
  74
  75         if (result == NULL) {
  76                 return -1;
  77         }
  78
  79         return 0;
  80 }
  81
  82 #define __vpp_sock(sock) (struct spdk_vpp_sock *)sock
  83 #define __vpp_group_impl(group) (struct spdk_vpp_sock_group_impl *)group
  84
  85 static inline void
  86 vcom_socket_copy_ep_to_sockaddr(struct sockaddr *addr, socklen_t *len, vppcom_endpt_t *ep)
  87 {
  88         int sa_len, copy_len;
  89
  90         assert(ep->vrf == VPPCOM_VRF_DEFAULT);
  91
  92         if (ep->is_ip4 == VPPCOM_IS_IP4) {
  93                 addr->sa_family = AF_INET;
  94                 ((struct sockaddr_in *) addr)->sin_port = ep->port;
  95                 if (*len > sizeof(struct sockaddr_in)) {
  96                         *len = sizeof(struct sockaddr_in);
  97                 }
  98                 sa_len = sizeof(struct sockaddr_in) - sizeof(struct in_addr);
  99                 copy_len = *len - sa_len;
 100                 if (copy_len > 0) {
 101                         memcpy(&((struct sockaddr_in *) addr)->sin_addr, ep->ip, copy_len);
 102                 }
 103         } else {
 104                 addr->sa_family = AF_INET6;
 105                 ((struct sockaddr_in6 *) addr)->sin6_port = ep->port;
 106                 if (*len > sizeof(struct sockaddr_in6)) {
 107                         *len = sizeof(struct sockaddr_in6);
 108                 }
 109                 sa_len = sizeof(struct sockaddr_in6) - sizeof(struct in6_addr);
 110                 copy_len = *len - sa_len;
 111                 if (copy_len > 0) {
 112                         memcpy(&((struct sockaddr_in6 *) addr)->sin6_addr, ep->ip, copy_len);
 113                 }
 114         }
 115 }
 116
 117 static int
 118 getsockname_vpp(int fd, struct sockaddr *addr, socklen_t *len)
 119 {
 120         vppcom_endpt_t ep;
 121         uint32_t size = sizeof(ep);
 122         uint8_t addr_buf[sizeof(struct in6_addr)];
 123         int rc;
 124
 125         if (!addr || !len) {
 126                 return -EFAULT;
 127         }
 128
 129         ep.ip = addr_buf;
 130
 131         rc = vppcom_session_attr(fd, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size);
 132         if (rc == VPPCOM_OK) {
 133                 vcom_socket_copy_ep_to_sockaddr(addr, len, &ep);
 134         }
 135
 136         return rc;
 137 }
 138
 139
 140 static int
 141 getpeername_vpp(int sock, struct sockaddr *addr, socklen_t *len)
 142 {
 143         vppcom_endpt_t ep;
 144         uint32_t size = sizeof(ep);
 145         uint8_t addr_buf[sizeof(struct in6_addr)];
 146         int rc;
 147
 148         if (!addr || !len) {
 149                 return -EFAULT;
 150         }
 151
 152         ep.ip = addr_buf;
 153
 154         rc = vppcom_session_attr(sock, VPPCOM_ATTR_GET_PEER_ADDR, &ep, &size);
 155         if (rc == VPPCOM_OK) {
 156                 vcom_socket_copy_ep_to_sockaddr(addr, len, &ep);
 157         }
 158
 159         return rc;
 160 }
 161
 162 static int
 163 spdk_vpp_sock_getaddr(struct spdk_sock *_sock, char *saddr, int slen, uint16_t *sport,
 164                       char *caddr, int clen, uint16_t *cport)
 165 {
 166         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 167         struct sockaddr sa;
 168         socklen_t salen;
 169         int rc;
 170
 171         assert(sock != NULL);
 172         assert(g_vpp_initialized);
 173
 174         memset(&sa, 0, sizeof(sa));
 175         salen = sizeof(sa);
 176         rc = getsockname_vpp(sock->fd, &sa, &salen);
 177         if (rc != 0) {
 178                 errno = -rc;
 179                 SPDK_ERRLOG("getsockname_vpp() failed (errno=%d)\n", errno);
 180                 return -1;
 181         }
 182
 183         rc = get_addr_str(&sa, saddr, slen);
 184         if (rc != 0) {
 185                 /* Errno already set by get_addr_str() */
 186                 SPDK_ERRLOG("get_addr_str() failed (errno=%d)\n", errno);
 187                 return -1;
 188         }
 189
 190         if (sport) {
 191                 if (sa.ss_family == AF_INET) {
 192                         *sport = ntohs(((struct sockaddr_in *) &sa)->sin_port);
 193                 } else if (sa.ss_family == AF_INET6) {
 194                         *sport = ntohs(((struct sockaddr_in6 *) &sa)->sin6_port);
 195                 }
 196         }
 197
 198         memset(&sa, 0, sizeof(sa));
 199         salen = sizeof(sa);
 200         rc = getpeername_vpp(sock->fd, &sa, &salen);
 201         if (rc != 0) {
 202                 errno = -rc;
 203                 SPDK_ERRLOG("getpeername_vpp() failed (errno=%d)\n", errno);
 204                 return -1;
 205         }
 206
 207         rc = get_addr_str(&sa, caddr, clen);
 208         if (rc != 0) {
 209                 /* Errno already set by get_addr_str() */
 210                 SPDK_ERRLOG("get_addr_str() failed (errno=%d)\n", errno);
 211                 return -1;
 212         }
 213
 214         if (cport) {
 215                 if (sa.ss_family == AF_INET) {
 216                         *cport = ntohs(((struct sockaddr_in *) &sa)->sin_port);
 217                 } else if (sa.ss_family == AF_INET6) {
 218                         *cport = ntohs(((struct sockaddr_in6 *) &sa)->sin6_port);
 219                 }
 220         }
 221
 222         return 0;
 223 }
 224
 225 enum spdk_vpp_create_type {
 226         SPDK_SOCK_CREATE_LISTEN,
 227         SPDK_SOCK_CREATE_CONNECT,
 228 };
 229
 230 static struct spdk_sock *
 231 spdk_vpp_sock_create(const char *ip, int port, enum spdk_vpp_create_type type)
 232 {
 233         struct spdk_vpp_sock *sock;
 234         int fd, rc;
 235         vppcom_endpt_t endpt;
 236         uint8_t addr_buf[sizeof(struct in6_addr)];
 237
 238         if (ip == NULL) {
 239                 return NULL;
 240         }
 241
 242         /* Check address family */
 243         if (inet_pton(AF_INET, ip, &addr_buf)) {
 244                 endpt.is_ip4 = VPPCOM_IS_IP4;
 245         } else if (inet_pton(AF_INET6, ip, &addr_buf)) {
 246                 endpt.is_ip4 = VPPCOM_IS_IP6;
 247         } else {
 248                 SPDK_ERRLOG("IP address with invalid format\n");
 249                 return NULL;
 250         }
 251         endpt.vrf = VPPCOM_VRF_DEFAULT;
 252         endpt.ip = (uint8_t *)&addr_buf;
 253         endpt.port = htons(port);
 254
 255         fd = vppcom_session_create(VPPCOM_VRF_DEFAULT, VPPCOM_PROTO_TCP, 1 /* is_nonblocking */);
 256         if (fd < 0) {
 257                 errno = -fd;
 258                 SPDK_ERRLOG("vppcom_session_create() failed, errno = %d\n", errno);
 259                 return NULL;
 260         }
 261
 262         if (type == SPDK_SOCK_CREATE_LISTEN) {
 263                 rc = vppcom_session_bind(fd, &endpt);
 264                 if (rc != VPPCOM_OK) {
 265                         errno = -rc;
 266                         SPDK_ERRLOG("vppcom_session_bind() failed, errno = %d\n", errno);
 267                         vppcom_session_close(fd);
 268                         return NULL;
 269                 }
 270
 271                 rc = vppcom_session_listen(fd, 512);
 272                 if (rc != VPPCOM_OK) {
 273                         errno = -rc;
 274                         SPDK_ERRLOG("vppcom_session_listen() failed, errno = %d\n", errno);
 275                         vppcom_session_close(fd);
 276                         return NULL;
 277                 }
 278         } else if (type == SPDK_SOCK_CREATE_CONNECT) {
 279                 rc = vppcom_session_connect(fd, &endpt);
 280                 if (rc != VPPCOM_OK) {
 281                         errno = -rc;
 282                         SPDK_ERRLOG("vppcom_session_connect() failed, errno = %d\n", errno);
 283                         vppcom_session_close(fd);
 284                         return NULL;
 285                 }
 286         }
 287
 288         sock = calloc(1, sizeof(*sock));
 289         if (sock == NULL) {
 290                 errno = -ENOMEM;
 291                 SPDK_ERRLOG("sock allocation failed\n");
 292                 vppcom_session_close(fd);
 293                 return NULL;
 294         }
 295
 296         sock->fd = fd;
 297         return &sock->base;
 298 }
 299
 300 static struct spdk_sock *
 301 spdk_vpp_sock_listen(const char *ip, int port)
 302 {
 303         if (!g_vpp_initialized) {
 304                 return NULL;
 305         }
 306
 307         return spdk_vpp_sock_create(ip, port, SPDK_SOCK_CREATE_LISTEN);
 308 }
 309
 310 static struct spdk_sock *
 311 spdk_vpp_sock_connect(const char *ip, int port)
 312 {
 313         if (!g_vpp_initialized) {
 314                 return NULL;
 315         }
 316
 317         return spdk_vpp_sock_create(ip, port, SPDK_SOCK_CREATE_CONNECT);
 318 }
 319
 320 static struct spdk_sock *
 321 spdk_vpp_sock_accept(struct spdk_sock *_sock)
 322 {
 323         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 324         vppcom_endpt_t          endpt;
 325         uint8_t                 ip[16];
 326         int                     rc;
 327         struct spdk_vpp_sock    *new_sock;
 328         double                  wait_time = -1.0;
 329
 330         endpt.ip = ip;
 331
 332         assert(sock != NULL);
 333         assert(g_vpp_initialized);
 334
 335         rc = vppcom_session_accept(sock->fd, &endpt, O_NONBLOCK, wait_time);
 336         if (rc < 0) {
 337                 errno = -rc;
 338                 return NULL;
 339         }
 340
 341         new_sock = calloc(1, sizeof(*sock));
 342         if (new_sock == NULL) {
 343                 SPDK_ERRLOG("sock allocation failed\n");
 344                 vppcom_session_close(rc);
 345                 return NULL;
 346         }
 347
 348         new_sock->fd = rc;
 349         return &new_sock->base;
 350 }
 351
 352 static int
 353 spdk_vpp_sock_close(struct spdk_sock *_sock)
 354 {
 355         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 356         int rc;
 357
 358         assert(sock != NULL);
 359         assert(g_vpp_initialized);
 360
 361         rc = vppcom_session_close(sock->fd);
 362         if (rc != VPPCOM_OK) {
 363                 errno = -rc;
 364                 return -1;
 365         }
 366         free(sock);
 367
 368         return 0;
 369 }
 370
 371 static ssize_t
 372 spdk_vpp_sock_recv(struct spdk_sock *_sock, void *buf, size_t len)
 373 {
 374         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 375         int rc;
 376
 377         assert(sock != NULL);
 378         assert(g_vpp_initialized);
 379
 380         rc = vppcom_session_read(sock->fd, buf, len);
 381         if (rc < 0) {
 382                 errno = -rc;
 383                 return -1;
 384         }
 385         return rc;
 386 }
 387
 388 static ssize_t
 389 spdk_vpp_sock_writev(struct spdk_sock *_sock, struct iovec *iov, int iovcnt)
 390 {
 391         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 392         ssize_t total = 0;
 393         int i, rc;
 394
 395         assert(sock != NULL);
 396         assert(g_vpp_initialized);
 397
 398         for (i = 0; i < iovcnt; ++i) {
 399                 rc = vppcom_session_write(sock->fd, iov[i].iov_base, iov[i].iov_len);
 400                 if (rc < 0) {
 401                         if (total > 0) {
 402                                 break;
 403                         } else {
 404                                 errno = -rc;
 405                                 return -1;
 406                         }
 407                 } else {
 408                         total += rc;
 409                 }
 410         }
 411         return total;
 412 }
 413
 414
 415 /*
 416  * TODO: Check if there are similar parameters to configure in VPP
 417  * to three below.
 418  */
 419 static int
 420 spdk_vpp_sock_set_recvlowat(struct spdk_sock *_sock, int nbytes)
 421 {
 422         assert(g_vpp_initialized);
 423
 424         return 0;
 425 }
 426
 427 static int
 428 spdk_vpp_sock_set_recvbuf(struct spdk_sock *_sock, int sz)
 429 {
 430         assert(g_vpp_initialized);
 431
 432         return 0;
 433 }
 434
 435 static int
 436 spdk_vpp_sock_set_sendbuf(struct spdk_sock *_sock, int sz)
 437 {
 438         assert(g_vpp_initialized);
 439
 440         return 0;
 441 }
 442
 443 static bool
 444 spdk_vpp_sock_is_ipv6(struct spdk_sock *_sock)
 445 {
 446         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 447         vppcom_endpt_t ep;
 448         uint32_t size = sizeof(ep);
 449         uint8_t addr_buf[sizeof(struct in6_addr)];
 450         int rc;
 451
 452         assert(sock != NULL);
 453         assert(g_vpp_initialized);
 454
 455         ep.ip = addr_buf;
 456
 457         rc = vppcom_session_attr(sock->fd, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size);
 458         if (rc != VPPCOM_OK) {
 459                 errno = -rc;
 460                 return false;
 461         }
 462
 463         return (ep.is_ip4 == VPPCOM_IS_IP6);
 464 }
 465
 466 static bool
 467 spdk_vpp_sock_is_ipv4(struct spdk_sock *_sock)
 468 {
 469         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 470         vppcom_endpt_t ep;
 471         uint32_t size = sizeof(ep);
 472         uint8_t addr_buf[sizeof(struct in6_addr)];
 473         int rc;
 474
 475         assert(sock != NULL);
 476         assert(g_vpp_initialized);
 477
 478         ep.ip = addr_buf;
 479
 480         rc = vppcom_session_attr(sock->fd, VPPCOM_ATTR_GET_LCL_ADDR, &ep, &size);
 481         if (rc != VPPCOM_OK) {
 482                 errno = -rc;
 483                 return false;
 484         }
 485
 486         return (ep.is_ip4 == VPPCOM_IS_IP4);
 487 }
 488
 489 static struct spdk_sock_group_impl *
 490 spdk_vpp_sock_group_impl_create(void)
 491 {
 492         struct spdk_vpp_sock_group_impl *group_impl;
 493         int fd;
 494
 495         if (!g_vpp_initialized) {
 496                 return NULL;
 497         }
 498
 499         group_impl = calloc(1, sizeof(*group_impl));
 500         if (group_impl == NULL) {
 501                 SPDK_ERRLOG("sock_group allocation failed\n");
 502                 return NULL;
 503         }
 504
 505         fd = vppcom_epoll_create();
 506         if (fd < 0) {
 507                 free(group_impl);
 508                 return NULL;
 509         }
 510
 511         group_impl->fd = fd;
 512
 513         return &group_impl->base;
 514 }
 515
 516 static int
 517 spdk_vpp_sock_group_impl_add_sock(struct spdk_sock_group_impl *_group, struct spdk_sock *_sock)
 518 {
 519         struct spdk_vpp_sock_group_impl *group = __vpp_group_impl(_group);
 520         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 521         int rc;
 522         struct epoll_event event;
 523
 524         assert(sock != NULL);
 525         assert(group != NULL);
 526         assert(g_vpp_initialized);
 527
 528         event.events = EPOLLIN;
 529         event.data.ptr = sock;
 530
 531         rc = vppcom_epoll_ctl(group->fd, EPOLL_CTL_ADD, sock->fd, &event);
 532         if (rc != VPPCOM_OK) {
 533                 errno = -rc;
 534                 return -1;
 535         }
 536
 537         return 0;
 538 }
 539
 540 static int
 541 spdk_vpp_sock_group_impl_remove_sock(struct spdk_sock_group_impl *_group, struct spdk_sock *_sock)
 542 {
 543         struct spdk_vpp_sock_group_impl *group = __vpp_group_impl(_group);
 544         struct spdk_vpp_sock *sock = __vpp_sock(_sock);
 545         int rc;
 546         struct epoll_event event;
 547
 548         assert(sock != NULL);
 549         assert(group != NULL);
 550         assert(g_vpp_initialized);
 551
 552         rc = vppcom_epoll_ctl(group->fd, EPOLL_CTL_DEL, sock->fd, &event);
 553         if (rc != VPPCOM_OK) {
 554                 errno = -rc;
 555                 return -1;
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int
 562 spdk_vpp_sock_group_impl_poll(struct spdk_sock_group_impl *_group, int max_events,
 563                               struct spdk_sock **socks)
 564 {
 565         struct spdk_vpp_sock_group_impl *group = __vpp_group_impl(_group);
 566         int num_events, i;
 567         struct epoll_event events[MAX_EVENTS_PER_POLL];
 568
 569         assert(group != NULL);
 570         assert(socks != NULL);
 571         assert(g_vpp_initialized);
 572
 573         num_events = vppcom_epoll_wait(group->fd, events, max_events, 0);
 574         if (num_events < 0) {
 575                 errno = -num_events;
 576                 return -1;
 577         }
 578
 579         for (i = 0; i < num_events; i++) {
 580                 socks[i] = events[i].data.ptr;
 581         }
 582
 583         return num_events;
 584 }
 585
 586 static int
 587 spdk_vpp_sock_group_impl_close(struct spdk_sock_group_impl *_group)
 588 {
 589         struct spdk_vpp_sock_group_impl *group = __vpp_group_impl(_group);
 590         int rc;
 591
 592         assert(group != NULL);
 593         assert(g_vpp_initialized);
 594
 595         rc = vppcom_session_close(group->fd);
 596         if (rc != VPPCOM_OK) {
 597                 errno = -rc;
 598                 return -1;
 599         }
 600
 601         return 0;
 602 }
 603
 604 static struct spdk_net_impl g_vpp_net_impl = {
 605         .name           = "vpp",
 606         .getaddr        = spdk_vpp_sock_getaddr,
 607         .connect        = spdk_vpp_sock_connect,
 608         .listen         = spdk_vpp_sock_listen,
 609         .accept         = spdk_vpp_sock_accept,
 610         .close          = spdk_vpp_sock_close,
 611         .recv           = spdk_vpp_sock_recv,
 612         .writev         = spdk_vpp_sock_writev,
 613         .set_recvlowat  = spdk_vpp_sock_set_recvlowat,
 614         .set_recvbuf    = spdk_vpp_sock_set_recvbuf,
 615         .set_sendbuf    = spdk_vpp_sock_set_sendbuf,
 616         .is_ipv6        = spdk_vpp_sock_is_ipv6,
 617         .is_ipv4        = spdk_vpp_sock_is_ipv4,
 618         .group_impl_create      = spdk_vpp_sock_group_impl_create,
 619         .group_impl_add_sock    = spdk_vpp_sock_group_impl_add_sock,
 620         .group_impl_remove_sock = spdk_vpp_sock_group_impl_remove_sock,
 621         .group_impl_poll        = spdk_vpp_sock_group_impl_poll,
 622         .group_impl_close       = spdk_vpp_sock_group_impl_close,
 623 };
 624
 625 SPDK_NET_IMPL_REGISTER(vpp, &g_vpp_net_impl);
 626
 627 static int
 628 spdk_vpp_net_framework_init(void)
 629 {
 630         int rc;
 631         char *app_name;
 632
 633         app_name = spdk_sprintf_alloc("SPDK_%d", getpid());
 634         if (app_name == NULL) {
 635                 SPDK_ERRLOG("Cannot alloc memory for SPDK app name\n");
 636                 return -ENOMEM;
 637         }
 638
 639         rc = vppcom_app_create(app_name);
 640         if (rc == 0) {
 641                 g_vpp_initialized = true;
 642         }
 643
 644         free(app_name);
 645
 646         return 0;
 647 }
 648
 649 static void
 650 spdk_vpp_net_framework_fini(void)
 651 {
 652         if (g_vpp_initialized) {
 653                 vppcom_app_destroy();
 654         }
 655 }
 656
 657 static struct spdk_net_framework g_vpp_net_framework = {
 658         .name   = "vpp",
 659         .init   = spdk_vpp_net_framework_init,
 660         .fini   = spdk_vpp_net_framework_fini,
 661 };
 662
 663 SPDK_NET_FRAMEWORK_REGISTER(vpp, &g_vpp_net_framework);