legacy-libs/grpc/deps/grpc/src/core/lib/iomgr/udp_server.h

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #ifndef GRPC_CORE_LIB_IOMGR_UDP_SERVER_H
  20 #define GRPC_CORE_LIB_IOMGR_UDP_SERVER_H
  21
  22 #include <grpc/support/port_platform.h>
  23
  24 #include "src/core/lib/gprpp/abstract.h"
  25 #include "src/core/lib/iomgr/endpoint.h"
  26 #include "src/core/lib/iomgr/ev_posix.h"
  27 #include "src/core/lib/iomgr/resolve_address.h"
  28
  29 /* Forward decl of struct grpc_server */
  30 /* This is not typedef'ed to avoid a typedef-redefinition error */
  31 struct grpc_server;
  32
  33 /* Forward decl of grpc_udp_server */
  34 typedef struct grpc_udp_server grpc_udp_server;
  35
  36 /* An interface associated with a socket. udp server delivers I/O event on that
  37  * socket to the subclass of this interface which is created through
  38  * GrpcUdpHandlerFactory.
  39  * Its implementation should do the real IO work, e.g. read packet and write. */
  40 class GrpcUdpHandler {
  41  public:
  42   GrpcUdpHandler(grpc_fd* emfd, void* user_data) {}
  43   virtual ~GrpcUdpHandler() {}
  44
  45   // Interfaces to be implemented by subclasses to do the actual setup/tear down
  46   // or I/O.
  47
  48   // Called when data is available to read from the socket. Returns true if
  49   // there is more data to read after this call.
  50   virtual bool Read() GRPC_ABSTRACT;
  51   // Called when socket becomes write unblocked. The given closure should be
  52   // scheduled when the socket becomes blocked next time.
  53   virtual void OnCanWrite(void* user_data,
  54                           grpc_closure* notify_on_write_closure) GRPC_ABSTRACT;
  55   // Called before the gRPC FD is orphaned. Notify udp server to continue
  56   // orphaning fd by scheduling the given closure, afterwards the associated fd
  57   // will be closed.
  58   virtual void OnFdAboutToOrphan(grpc_closure* orphan_fd_closure,
  59                                  void* user_data) GRPC_ABSTRACT;
  60
  61   GRPC_ABSTRACT_BASE_CLASS
  62 };
  63
  64 class GrpcUdpHandlerFactory {
  65  public:
  66   virtual ~GrpcUdpHandlerFactory() {}
  67   /* Called when start to listen on a socket.
  68    * Return an instance of the implementation of GrpcUdpHandler interface which
  69    * will process I/O events for this socket from now on. */
  70   virtual GrpcUdpHandler* CreateUdpHandler(grpc_fd* emfd,
  71                                            void* user_data) GRPC_ABSTRACT;
  72   virtual void DestroyUdpHandler(GrpcUdpHandler* handler) GRPC_ABSTRACT;
  73
  74   GRPC_ABSTRACT_BASE_CLASS
  75 };
  76
  77 /* Create a server, initially not bound to any ports */
  78 grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
  79
  80 /* Start listening to bound ports. user_data is passed to callbacks. */
  81 void grpc_udp_server_start(grpc_udp_server* udp_server, grpc_pollset** pollsets,
  82                            size_t pollset_count, void* user_data);
  83
  84 int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
  85
  86 /* Add a port to the server, returning port number on success, or negative
  87    on failure.
  88
  89    Create |num_listeners| sockets for given address to listen on using
  90    SO_REUSEPORT if supported.
  91
  92    The :: and 0.0.0.0 wildcard addresses are treated identically, accepting
  93    both IPv4 and IPv6 connections, but :: is the preferred style. This usually
  94    creates |num_listeners| sockets, but possibly 2 * |num_listeners| on systems
  95    which support IPv6, but not dualstack sockets. */
  96
  97 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
  98                   all of the multiple socket port matching logic in one place */
  99 int grpc_udp_server_add_port(grpc_udp_server* s,
 100                              const grpc_resolved_address* addr,
 101                              int rcv_buf_size, int snd_buf_size,
 102                              GrpcUdpHandlerFactory* handler_factory,
 103                              size_t num_listeners);
 104
 105 void grpc_udp_server_destroy(grpc_udp_server* server, grpc_closure* on_done);
 106
 107 #endif /* GRPC_CORE_LIB_IOMGR_UDP_SERVER_H */