1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 
17 #ifndef RIL_SOCKET_H_INCLUDED
18 #define RIL_SOCKET_H_INCLUDED
19 #include <libril/ril_ex.h>
20 #include "rilSocketQueue.h"
21 #include <ril_event.h>
22 
23 using namespace std;
24 
25 extern "C" void *ril_socket_process_requests_loop(void *arg);
26 
27 /**
28  * Abstract socket class representing sockets in rild.
29  * <p>
30  * This class performs the following functions :
31  * <ul>
32  *     <li> Start socket listen.
33  *     <li> Handle socket listen and command callbacks.
34  * </ul>
35  */
36 class RilSocket {
37     protected:
38 
39         /**
40          * Socket name.
41          */
42         const char* name;
43 
44         /**
45          * Socket id.
46          */
47         RIL_SOCKET_ID id;
48 
49        /**
50         * Listen socket file descriptor.
51         */
52         int listenFd = -1;
53 
54        /**
55         * Commands socket file descriptor.
56         */
57         int commandFd = -1;
58 
59        /**
60         * Socket request loop thread id.
61         */
62         pthread_t socketThreadId;
63 
64        /**
65         * Listen event callack. Callback called when the other ends does accept.
66         */
67         ril_event_cb listenCb;
68 
69        /**
70         * Commands event callack.Callback called when there are requests from the other side.
71         */
72         ril_event_cb commandCb;
73 
74         /**
75          * Listen event to be added to eventloop after socket listen.
76          */
77         struct ril_event listenEvent;
78 
79         /**
80          * Commands event to be added to eventloop after accept.
81          */
82         struct ril_event callbackEvent;
83 
84         /**
85          * Static socket listen handler. Chooses the socket to call the listen callback
86          * from ril.cpp.
87          *
88          * @param Listen fd.
89          * @param flags.
90          * @param Parameter for the listen handler.
91          */
92         static void sSocketListener(int fd, short flags, void *param);
93 
94         /**
95          * Static socket request handler. Chooses the socket to call the request handler on.
96          *
97          * @param Commands fd.
98          * @param flags.
99          * @param Parameter for the request handler.
100          */
101         static void sSocketRequestsHandler(int fd, short flags, void *param);
102 
103         /**
104          * Process record from the record stream and push the requests onto the queue.
105          *
106          * @param record data.
107          * @param record length.
108          */
109         virtual void pushRecord(void *record, size_t recordlen) = 0;
110 
111         /**
112          * Socket lock for writing data on the socket.
113          */
114         pthread_mutex_t write_lock = PTHREAD_MUTEX_INITIALIZER;
115 
116         /**
117          * The loop to process the incoming requests.
118          */
119         virtual void *processRequestsLoop(void) = 0;
120 
121     private:
122         friend void *::ril_socket_process_requests_loop(void *arg);
123 
124     public:
125 
126         /**
127          * Constructor.
128          *
129          * @param Socket name.
130          * @param Socket id.
131          */
RilSocket(const char * socketName,RIL_SOCKET_ID socketId)132         RilSocket(const char* socketName, RIL_SOCKET_ID socketId) {
133             name = socketName;
134             id = socketId;
135         }
136 
137         /**
138          * Clean up function on commands socket close.
139          */
140         virtual void onCommandsSocketClosed(void) = 0;
141 
142         /**
143          * Function called on new commands socket connect. Request loop thread is started here.
144          */
145         void onNewCommandConnect(void);
146 
147         /**
148          * Set listen socket fd.
149          *
150          * @param Input fd.
151          */
152         void setListenFd(int listenFd);
153 
154         /**
155          * Set commands socket fd.
156          *
157          * @param Input fd.
158          */
159         void setCommandFd(int commandFd);
160 
161         /**
162          * Get listen socket fd.
163          *
164          * @return Listen fd.
165          */
166         int getListenFd(void);
167 
168         /**
169          * Get commands socket fd.
170          *
171          * @return Commands fd.
172          */
173         int getCommandFd(void);
174 
175         /**
176          * Set listen event callback.
177          *
178          * @param Input event callback.
179          */
180         void setListenCb(ril_event_cb listenCb);
181 
182         /**
183          * Set command event callback.
184          *
185          * @param Input event callback.
186          */
187         void setCommandCb(ril_event_cb commandCb);
188 
189         /**
190          * Get listen event callback.
191          *
192          * @return Listen event callback.
193          */
194         ril_event_cb getListenCb(void);
195 
196         /**
197          * Gey command event callback.
198          *
199          * @return Command event callback.
200          */
201         ril_event_cb getCommandCb(void);
202 
203         /**
204          * Set listen event.
205          *
206          * @param Input event.
207          */
208         void setListenEvent(ril_event listenEvent);
209 
210         /**
211          * Set command callback event.
212          *
213          * @param Input event.
214          */
215         void setCallbackEvent(ril_event commandEvent);
216 
217         /**
218          * Get listen event.
219          *
220          * @return Listen event.
221          */
222         ril_event* getListenEvent(void);
223 
224         /**
225          * Get commands callback event.
226          *
227          * @return Commands callback event.
228          */
229         ril_event* getCallbackEvent(void);
230 
~RilSocket()231         virtual ~RilSocket(){}
232 
233     protected:
234 
235         /**
236          * Start listening on the socket and add the socket listen callback event.
237          *
238          * @return Result of the socket listen.
239          */
240         int socketInit(void);
241 
242         /**
243          * Socket request handler
244          *
245          * @param Commands fd.
246          * @param flags.
247          * @param Record stream.
248          */
249         void socketRequestsHandler(int fd, short flags, RecordStream *rs);
250 };
251 
252 class socketClient {
253     public:
254         RilSocket *socketPtr;
255         RecordStream *rs;
256 
socketClient(RilSocket * socketPtr,RecordStream * rs)257         socketClient(RilSocket *socketPtr, RecordStream *rs) {
258             this->socketPtr = socketPtr;
259             this->rs = rs;
260         }
261 };
262 
263 typedef struct MySocketListenParam {
264     SocketListenParam sListenParam;
265     RilSocket *socket;
266 } MySocketListenParam;
267 
268 typedef void* (RilSocket::*RilSocketFuncPtr)(void);
269 typedef void (RilSocket::*RilSocketEventPtr)(int fd,short flags, void *param);
270 typedef void* (*PthreadPtr)(void*);
271 
272 #endif
273