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:
GrpcUdpHandler(grpc_fd * emfd,void * user_data)42   GrpcUdpHandler(grpc_fd* emfd, void* user_data) {}
~GrpcUdpHandler()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:
~GrpcUdpHandlerFactory()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 */
108