Belle II Software release-09-00-03
Public Member Functions | Private Attributes | List of all members
SocketRecv Class Reference
Packages » daq
Inheritance diagram for SocketRecv:
Inheritance graph
[legend]
Collaboration diagram for SocketRecv:
Collaboration graph
[legend]

Public Member Functions

 SocketRecv (u_short port)
 
int examine ()
 
int accept ()
 
int close ()
 
int sock () const
 
int sender () const
 
void sock (int sockid)
 
int get (char *data, int len)
 
int get_wordbuf (int *data, int len)
 
int read (char *data, int len)
 
int put (char *data, int len)
 
int write (char *data, int len)
 
int err () const
 
void interrupt ()
 
int put (int sock, char *data, int len)
 
int put_wordbuf (int sock, int *data, int len)
 
int get (int sock, char *data, int len)
 
int get_wordbuf (int sock, int *data, int len)
 
int get_pxd (int sock, char *data, int len)
 
int read_data (int sock, char *data, int len)
 
int write_data (int sock, char *data, int len)
 

Private Attributes

SocketIO m_io
 
int m_sock
 
int m_sender
 
int m_errno
 
int m_int
 

Detailed Description

Definition at line 48 of file SocketLib.h.

Constructor & Destructor Documentation

◆ SocketRecv()

SocketRecv ( u_short  port)

Definition at line 204 of file SocketLib.cc.

205{
206
207 struct sockaddr_in sa;
208 bzero(&sa, sizeof(struct sockaddr_in));
209
210 m_errno = 0;
211
212 sa.sin_family = AF_INET;
213 sa.sin_port = htons(p);
214
215 int s;
216 if ((s = ::socket(AF_INET, SOCK_STREAM, 0)) < 0) {
217 m_errno = errno;
218 perror("SocketRecv::socket");
219 return;
220 }
221
222 int optval = 1;
223 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &optval, 4);
224
225 int sizeval = D2_SOCKBUF_SIZE;
226 setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sizeval, 4);
227 setsockopt(s, SOL_SOCKET, SO_RCVBUF, &sizeval, 4);
228
229 signal(SIGPIPE, SIG_IGN); // ignore SIGPIPE
230 // printf ( "SocketRecv: SIGPIPE will be ignored\n" );
231 // fflush ( stdout );
232
233 if ((bind(s, (struct sockaddr*)&sa, sizeof(sa))) < 0) {
234 m_errno = errno;
235 perror("SocketRecv::bind");
236 return;
237 }
238
239 m_sock = s;
240 m_sender = 0;
241 listen(s, 3);
242 printf("SocketRecv:: initialized, sock=%d\n", m_sock);
243
244 return;
245
246}

◆ ~SocketRecv()

~SocketRecv ( )

Definition at line 248 of file SocketLib.cc.

249{
250 if (m_sender > 0) {
251 shutdown(m_sender, 2);
252 ::close(m_sender);
253 printf("SocketRecv:: receiving socket %d closed\n", m_sender);
254 }
255
256 shutdown(m_sock, 2);
257 ::close(m_sock);
258 printf("SocketRecv:: connection socket %d closed\n", m_sock);
259}

Member Function Documentation

◆ accept()

int accept ( )

Definition at line 261 of file SocketLib.cc.

262{
263 m_errno = 0;
264 struct sockaddr_in isa;
265 socklen_t i = sizeof(isa);
266 getsockname(m_sock, (struct sockaddr*)&isa, &i);
267
268 int t;
269 if ((t =::accept(m_sock, (struct sockaddr*)&isa, &i)) < 0) {
270 m_errno = errno;
271 return (-1);
272 }
273
274 printf("SocketRecv:: connection request accepted, sender=%d\n", t);
275
276 m_sender = t;
277 return (t);
278}

◆ close()

int close ( )

Definition at line 280 of file SocketLib.cc.

281{
282 // ::close ( m_sender );
283 // m_sender = 0;
284 printf("SocketRecv: destructed, m_sender = %d\n", m_sender);
285 return 0;
286}

◆ err()

int err ( ) const

Definition at line 377 of file SocketLib.cc.

378{
379 return m_errno;
380}

◆ examine()

int examine ( )

Definition at line 288 of file SocketLib.cc.

289{
290 // printf("SocketRecv::examine(): waiting for client connection ...\n");
291
292 m_errno = 0;
293 fd_set ready;
294 FD_ZERO(&ready);
295 FD_SET(m_sock, &ready);
296 struct timeval to;
297 to.tv_sec = 0;
298 to.tv_usec = 0;
299 if (select(FD_SETSIZE, &ready, 0, 0, &to) < 0) {
300 m_errno = errno;
301 perror("select");
302 return (-1);
303 }
304 if (FD_ISSET(m_sock, &ready)) {
305 printf("SocketRecv::connected!!!!\n");
306 return (1);
307 } else
308 return (0);
309}

◆ get() [1/2]

int get ( char *  data,
int  len 
)

Definition at line 311 of file SocketLib.cc.

312{
313 // printf("SocketSend::get()\n");
314
315 m_errno = 0;
316 if (m_sender > 0)
317 return m_io.get(m_sender, data, len);
318 else
319 return -1;
320}

◆ get() [2/2]

int get ( int  sock,
char *  data,
int  len 
)
inherited

Definition at line 95 of file SocketLib.cc.

96{
97 int gcount;
98 int br = read_data(sock, (char*)&gcount, 4);
99 if (br <= 0) return br;
100 gcount = ntohl(gcount);
101 if (gcount > len) {
102 printf("buffer too small : %d(%d)", gcount, len);
103 exit(0);
104 }
105 int bcount = read_data(sock, data, gcount);
106 return (bcount);
107}

◆ get_pxd()

int get_pxd ( int  sock,
char *  data,
int  len 
)
inherited

as this is fixed .... might not be needed if taken care of in unpacker

Definition at line 126 of file SocketLib.cc.

127{
128#define MAX_PXD_FRAMES 256
129 const int headerlen = 8;
130 int* pxdheader = (int*) data; // TODO should it be unsigned int?
131 int* pxdheadertable = (int*) &data[headerlen]; // TODO should it be unsigned int?
132 int framenr = 0, tablelen = 0, datalen = 0;
133 int br = read_data(sock, data, headerlen);
134 if (br <= 0) return br;
135 if (static_cast<uint>(pxdheader[0]) != htonl(0xCAFEBABE)) {
136 printf("pxdheader wrong : Magic %X , Frames %X \n", pxdheader[0], ntohl(pxdheader[1]));
137 exit(0);
138 }
139 pxdheader[0] = ntohl(pxdheader[0]);
140 framenr = pxdheader[1] = ntohl(pxdheader[1]);
141 if (framenr > MAX_PXD_FRAMES) {
142 printf("MAX_PXD_FRAMES too small : %d(%d) \n", framenr, MAX_PXD_FRAMES);
143 exit(0);
144 }
145 tablelen = 4 * framenr;
146 br = read_data(sock, (char*)&data[headerlen], tablelen);
147 if (br <= 0) return br;
148 for (int i = 0; i < framenr; i++) {
149 pxdheadertable[i] = ntohl(pxdheadertable[i]);
150 datalen += (pxdheadertable[i] + 3) & 0xFFFFFFFC;
151 }
152
153 if (datalen + headerlen + tablelen > len) {
154 printf("buffer too small : %d %d %d(%d) \n", headerlen, tablelen, datalen, len);
155 exit(0);
156 }
157 int bcount = read_data(sock, data + headerlen + tablelen, datalen);
158 return (headerlen + tablelen + bcount);
159}

◆ get_wordbuf() [1/2]

int get_wordbuf ( int *  data,
int  len 
)

Definition at line 322 of file SocketLib.cc.

323{
324 // printf("SocketSend::get()\n");
325
326 m_errno = 0;
327 if (m_sender > 0)
328 return m_io.get_wordbuf(m_sender, data, len);
329 else
330 return -1;
331}

◆ get_wordbuf() [2/2]

int get_wordbuf ( int  sock,
int *  data,
int  len 
)
inherited

Definition at line 109 of file SocketLib.cc.

110{
111 int gcount;
112 int br = read_data(sock, (char*)wrdbuf, sizeof(int));
113 if (br <= 0) return br;
114 // gcount = ntohl(wrdbuf[0]);
115 gcount = wrdbuf[0];
116 // printf ( "gcount = %8.8x (%d)\n", gcount, gcount );
117 if (gcount > len) {
118 printf("buffer too small : %d(%d)", gcount, len);
119 exit(0);
120 }
121 read_data(sock, (char*)&wrdbuf[1], (gcount - 1) * sizeof(int));
122 // printf ( "term = %8.8x\n", wrdbuf[gcount-1] );
123 return (wrdbuf[0]);
124}

◆ interrupt()

void interrupt ( void  )

Definition at line 382 of file SocketLib.cc.

383{
384 m_io.interrupt();
385}

◆ put() [1/2]

int put ( char *  data,
int  len 
)

Definition at line 342 of file SocketLib.cc.

343{
344 // printf("SocketRecv::put (sd = %d)\n", m_sender);
345 m_errno = 0;
346 if (m_sender > 0)
347 return m_io.put(m_sender, data, len);
348 else
349 return -1;
350}

◆ put() [2/2]

int put ( int  sock,
char *  data,
int  len 
)
inherited

Definition at line 36 of file SocketLib.cc.

37{
38 int to_size = htonl(len);
39 // printf("SocketIO::put(%d): sending size...\n",sock);
40 int br = write_data(sock, (char*)&to_size, 4);
41 if (br < 0) {
42 perror("put: sending size");
43 return br;
44 }
45 // printf("SocketIO::put(%d): sending data...\n",sock);
46 int bcount = write_data(sock, data, len);
47 if (bcount < 0) perror("put: sending data");
48 return (bcount);
49}

◆ put_wordbuf()

int put_wordbuf ( int  sock,
int *  data,
int  len 
)
inherited

Definition at line 51 of file SocketLib.cc.

52{
53 // printf("SocketIO::put_wordbuf(%d): sending data...\n",sock);
54 int bcount = write_data(sock, (char*)data, len * sizeof(int));
55 if (bcount < 0) perror("put: sending data");
56 if (bcount <= 0)
57 return bcount;
58 else
59 return ((bcount - 1) / 4 + 1);
60}

◆ read()

int read ( char *  data,
int  len 
)

Definition at line 333 of file SocketLib.cc.

334{
335 m_errno = 0;
336 if (m_sender > 0)
337 return m_io.read_data(m_sender, data, len);
338 else
339 return -1;
340}

◆ read_data()

int read_data ( int  sock,
char *  data,
int  len 
)
inherited

Definition at line 161 of file SocketLib.cc.

162{
163 char* buf = data;
164 int bcount = 0;
165
166 while (bcount < len) {
167 int br = 0;
168 if ((br =::read(sock, buf, len - bcount)) > 0) {
169 bcount += br;
170 buf += br;
171 }
172 fflush(stdout);
173 if (br == 0) return 0;
174 if (br < 0) {
175 switch (errno) {
176 case EINTR:
177 if (m_int == 1) {
178 printf("read: interrupted!\n");
179 m_int = 0;
180 return -2;
181 } else
182 // continue;
183 return -1;
184 case EAGAIN:
185 continue;
186 default:
187 perror("SocketIO:read");
188 fprintf(stderr, "sock = %d, buf=%p, len = %d\n", sock, buf, len - bcount);
189 return -1;
190 }
191 }
192 }
193 // printf ( "SocketIO::read_data ended : bcount = %d!!!\n", bcount );
194 return (bcount);
195}

◆ sender()

int sender ( ) const

Definition at line 372 of file SocketLib.cc.

373{
374 return m_sender;
375}

◆ sock() [1/2]

int sock ( ) const

Definition at line 362 of file SocketLib.cc.

363{
364 return m_sock;
365}

◆ sock() [2/2]

void sock ( int  sockid)

Definition at line 367 of file SocketLib.cc.

368{
369 m_sock = sockid;
370}

◆ write()

int write ( char *  data,
int  len 
)

Definition at line 352 of file SocketLib.cc.

353{
354 m_errno = 0;
355 if (m_sender > 0)
356 return m_io.write_data(m_sender, data, len);
357 else
358 return -1;
359}

◆ write_data()

int write_data ( int  sock,
char *  data,
int  len 
)
inherited

Definition at line 62 of file SocketLib.cc.

63{
64 errno = 0;
65 char* ptr = data;
66 int bcount = 0;
67
68 // printf("write_data( sock=%d. data=%p. len=%d )\n", sock, data, len);
69
70 while (bcount < len) {
71 int br = 0;
72 if ((br =::write(sock, ptr, len - bcount)) > 0) {
73 bcount += br;
74 ptr += br;
75 }
76 if (br < 0) {
77 switch (errno) {
78 case EINTR:
79 return -1;
80 // continue;
81 case EPIPE:
82 return -1; // connection closed, sigpipe
83 case ENETUNREACH:
84 case EHOSTUNREACH:
85 case ETIMEDOUT:
86 usleep(500);
87 continue;
88 default: return -1;
89 }
90 }
91 }
92 return (bcount);
93}

Member Data Documentation

◆ m_errno

int m_errno
private

Definition at line 74 of file SocketLib.h.

◆ m_int

int m_int
privateinherited

Definition at line 44 of file SocketLib.h.

◆ m_io

SocketIO m_io
private

Definition at line 71 of file SocketLib.h.

◆ m_sender

int m_sender
private

Definition at line 73 of file SocketLib.h.

◆ m_sock

int m_sock
private

Definition at line 72 of file SocketLib.h.

The documentation for this class was generated from the following files: