summaryrefslogtreecommitdiff
authorMarek Vasut <marek.vasut@gmail.com>2007-07-14 22:09:38 (UTC)
committer Michael Krelin <hacker@klever.net>2007-07-15 18:33:28 (UTC)
commit9dacb2c97939fad573446c0858f6b536b3d7bf15 (patch) (unidiff)
tree6cb098508e6513f67d608278bf6f61a08fb6d158
parent15fbd2a9189281ca84d89ad6a77261d0046add36 (diff)
downloadopie-9dacb2c97939fad573446c0858f6b536b3d7bf15.zip
opie-9dacb2c97939fad573446c0858f6b536b3d7bf15.tar.gz
opie-9dacb2c97939fad573446c0858f6b536b3d7bf15.tar.bz2
obex receive fixes
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--core/obex/obexserver.cpp25
1 files changed, 14 insertions, 11 deletions
diff --git a/core/obex/obexserver.cpp b/core/obex/obexserver.cpp
index f1fb205..786e9f7 100644
--- a/core/obex/obexserver.cpp
+++ b/core/obex/obexserver.cpp
@@ -114,193 +114,204 @@ static int put_done(obex_t* handle, obex_object_t* object)
114 case OBEX_HDR_BODY: 114 case OBEX_HDR_BODY:
115 body = hv.bs; 115 body = hv.bs;
116 body_len = hlen; 116 body_len = hlen;
117 break; 117 break;
118 118
119 case OBEX_HDR_NAME: 119 case OBEX_HDR_NAME:
120 name = new uint8_t[(hlen / 2) + 1]; 120 name = new uint8_t[(hlen / 2) + 1];
121 OBEX_UnicodeToChar(name, hv.bs, hlen); 121 OBEX_UnicodeToChar(name, hv.bs, hlen);
122 break; 122 break;
123 123
124 default: 124 default:
125 break; 125 break;
126 } 126 }
127 } 127 }
128 128
129 if (body) 129 if (body)
130 err = file_received(name, body, body_len); 130 err = file_received(name, body, body_len);
131 131
132 if (name) 132 if (name)
133 delete[] name; 133 delete[] name;
134 return err; 134 return err;
135} 135}
136 136
137/** 137/**
138 * Function handles OBEX request 138 * Function handles OBEX request
139 * @param handle OBEX connection handle 139 * @param handle OBEX connection handle
140 * @param object OBEX object itself 140 * @param object OBEX object itself
141 * @param mode 141 * @param mode
142 * @param event event code 142 * @param event event code
143 * @param cmd OBEX command itself 143 * @param cmd OBEX command itself
144 */ 144 */
145static void handle_request (obex_t* handle, obex_object_t* object, 145static void handle_request (obex_t* handle, obex_object_t* object,
146 int event, int cmd) 146 int event, int cmd)
147{ 147{
148 (void)event; 148 (void)event;
149 switch(cmd){ 149 switch(cmd){
150 case OBEX_CMD_SETPATH: 150 case OBEX_CMD_SETPATH:
151 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS); 151 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
152 break; 152 break;
153 case OBEX_CMD_PUT: 153 case OBEX_CMD_PUT:
154 if (put_done (handle, object) < 0) 154 if (put_done (handle, object) < 0)
155 OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR, 155 OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR,
156 OBEX_RSP_INTERNAL_SERVER_ERROR); 156 OBEX_RSP_INTERNAL_SERVER_ERROR);
157 else 157 else
158 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS); 158 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
159 break; 159 break;
160 case OBEX_CMD_CONNECT: 160 case OBEX_CMD_CONNECT:
161 OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS); 161 OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
162 break; 162 break;
163 case OBEX_CMD_DISCONNECT: 163 case OBEX_CMD_DISCONNECT:
164 OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS); 164 OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
165 break; 165 break;
166 default: 166 default:
167 printf("Denied %02x request\n", cmd); 167 printf("Denied %02x request\n", cmd);
168 fflush(stdout); 168 fflush(stdout);
169 OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED, 169 OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
170 OBEX_RSP_NOT_IMPLEMENTED); 170 OBEX_RSP_NOT_IMPLEMENTED);
171 break; 171 break;
172 } 172 }
173} 173}
174 174
175 175
176/** 176/**
177 * Function handles OBEX event when a client is connected to the server 177 * Function handles OBEX event when a client is connected to the server
178 * @param handle OBEX connection handle 178 * @param handle OBEX connection handle
179 * @param object OBEX object itself 179 * @param object OBEX object itself
180 * @param mode 180 * @param mode
181 * @param event event code 181 * @param event event code
182 * @param obex_cmd OBEX command itself 182 * @param obex_cmd OBEX command itself
183 * @param obex_rsp OBEX responce 183 * @param obex_rsp OBEX responce
184 */ 184 */
185static void obex_conn_event (obex_t *handle, obex_object_t *object, 185static void obex_conn_event (obex_t *handle, obex_object_t *object,
186 int mode, int event, int obex_cmd, int obex_rsp) 186 int mode, int event, int obex_cmd, int obex_rsp)
187{ 187{
188 (void)mode; 188 (void)mode;
189 (void)obex_rsp; 189 (void)obex_rsp;
190 190
191 switch(event) { 191 switch(event) {
192 case OBEX_EV_REQHINT: 192 case OBEX_EV_REQHINT:
193 switch(obex_cmd) { 193 switch(obex_cmd) {
194 case OBEX_CMD_PUT: 194 case OBEX_CMD_PUT:
195 case OBEX_CMD_CONNECT: 195 case OBEX_CMD_CONNECT:
196 case OBEX_CMD_DISCONNECT: 196 case OBEX_CMD_DISCONNECT:
197 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS); 197 OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
198 break; 198 break;
199 default: 199 default:
200 OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED, 200 OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
201 OBEX_RSP_NOT_IMPLEMENTED); 201 OBEX_RSP_NOT_IMPLEMENTED);
202 break; 202 break;
203 } 203 }
204 break; 204 break;
205 205
206 case OBEX_EV_REQ: 206 case OBEX_EV_REQ:
207 /* Comes when a server-request has been received. */ 207 /* Comes when a server-request has been received. */
208 handle_request (handle, object, event, obex_cmd); 208 handle_request (handle, object, event, obex_cmd);
209 break; 209 break;
210 210 case OBEX_EV_REQDONE:
211 switch(obex_cmd) {
212 case OBEX_CMD_PUT:
213 case OBEX_CMD_CONNECT:
214 break;
215 case OBEX_CMD_DISCONNECT:
216 OBEX_TransportDisconnect(handle);
217 break;
218 default:
219 break;
220 }
221 break;
211 case OBEX_EV_LINKERR: 222 case OBEX_EV_LINKERR:
212 break; 223 break;
213 } 224 }
214} 225}
215 226
216/** 227/**
217 * Function handles OBEX event 228 * Function handles OBEX event
218 * @param handle OBEX connection handle 229 * @param handle OBEX connection handle
219 * @param object OBEX object itself 230 * @param object OBEX object itself
220 * @param mode 231 * @param mode
221 * @param event event code 232 * @param event event code
222 * @param obex_cmd OBEX command itself 233 * @param obex_cmd OBEX command itself
223 * @param obex_rsp OBEX responce 234 * @param obex_rsp OBEX responce
224 */ 235 */
225static void obex_event (obex_t* handle, obex_object_t* object, int mode, 236static void obex_event (obex_t* handle, obex_object_t* object, int mode,
226 int event, int obex_cmd, int obex_rsp) 237 int event, int obex_cmd, int obex_rsp)
227{ 238{
228 239
229 obex_t *obex; //OBEX connection handle 240 obex_t *obex; //OBEX connection handle
230 241
231 switch (event) { 242 switch (event) {
232 case OBEX_EV_ACCEPTHINT: 243 case OBEX_EV_ACCEPTHINT:
233 obex = OBEX_ServerAccept (handle, obex_conn_event, NULL); 244 obex = OBEX_ServerAccept (handle, obex_conn_event, NULL);
234 break; 245 break;
235 246
236 default: 247 default:
237 obex_conn_event(handle, object, mode, event, obex_cmd, obex_rsp); 248 obex_conn_event(handle, object, mode, event, obex_cmd, obex_rsp);
238 } 249 }
239} 250}
240 251
241/** 252/**
242 * Function registers OBEX push service on a specified channel 253 * Function registers OBEX push service on a specified channel
243 * Based on The same function from GPE. 254 * Based on The same function from GPE.
244 * @param session SDP session 255 * @param session SDP session
245 * @param chan channel to listen 256 * @param chan channel to listen
246 * @name name to show 257 * @name name to show
247 */ 258 */
248sdp_session_t* ObexServer::addOpushSvc(uint8_t chan, const char* name) 259sdp_session_t* ObexServer::addOpushSvc(uint8_t chan, const char* name)
249{ 260{
250 sdp_list_t *svclass_id, *pfseq, *apseq, *root; 261 sdp_list_t *svclass_id, *pfseq, *apseq, *root;
251 uuid_t root_uuid, opush_uuid, l2cap_uuid, rfcomm_uuid, obex_uuid; 262 uuid_t root_uuid, opush_uuid, l2cap_uuid, rfcomm_uuid, obex_uuid;
252 sdp_profile_desc_t profile[1]; 263 sdp_profile_desc_t profile[1];
253 sdp_list_t *aproto, *proto[3]; 264 sdp_list_t *aproto, *proto[3];
254 sdp_record_t record; 265 sdp_record_t record;
255 sdp_data_t *channel; 266 sdp_data_t *channel;
256 uint8_t formats[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; 267 uint8_t formats[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
257 //uint8_t formats[] = { 0xff }; 268 //uint8_t formats[] = { 0xff };
258 void *dtds[sizeof(formats)], *values[sizeof(formats)]; 269 void *dtds[sizeof(formats)], *values[sizeof(formats)];
259 unsigned int i; 270 unsigned int i;
260 uint8_t dtd = SDP_UINT8; 271 uint8_t dtd = SDP_UINT8;
261 sdp_data_t *sflist; 272 sdp_data_t *sflist;
262 int err = 0; 273 int err = 0;
263 sdp_session_t* lsession = 0; 274 sdp_session_t* lsession = 0;
264 275
265 memset((void *)&record, 0, sizeof(sdp_record_t)); 276 memset((void *)&record, 0, sizeof(sdp_record_t));
266 record.handle = 0xffffffff; 277 record.handle = 0xffffffff;
267 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); 278 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
268 root = sdp_list_append(0, &root_uuid); 279 root = sdp_list_append(0, &root_uuid);
269 sdp_set_browse_groups(&record, root); 280 sdp_set_browse_groups(&record, root);
270 281
271 sdp_uuid16_create(&opush_uuid, OBEX_OBJPUSH_SVCLASS_ID); 282 sdp_uuid16_create(&opush_uuid, OBEX_OBJPUSH_SVCLASS_ID);
272 svclass_id = sdp_list_append(0, &opush_uuid); 283 svclass_id = sdp_list_append(0, &opush_uuid);
273 sdp_set_service_classes(&record, svclass_id); 284 sdp_set_service_classes(&record, svclass_id);
274 285
275 sdp_uuid16_create(&profile[0].uuid, OBEX_OBJPUSH_PROFILE_ID); 286 sdp_uuid16_create(&profile[0].uuid, OBEX_OBJPUSH_PROFILE_ID);
276 profile[0].version = 0x0100; 287 profile[0].version = 0x0100;
277 pfseq = sdp_list_append(0, profile); 288 pfseq = sdp_list_append(0, profile);
278 sdp_set_profile_descs(&record, pfseq); 289 sdp_set_profile_descs(&record, pfseq);
279 290
280 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); 291 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
281 proto[0] = sdp_list_append(0, &l2cap_uuid); 292 proto[0] = sdp_list_append(0, &l2cap_uuid);
282 apseq = sdp_list_append(0, proto[0]); 293 apseq = sdp_list_append(0, proto[0]);
283 294
284 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); 295 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
285 proto[1] = sdp_list_append(0, &rfcomm_uuid); 296 proto[1] = sdp_list_append(0, &rfcomm_uuid);
286 channel = sdp_data_alloc(SDP_UINT8, &chan); 297 channel = sdp_data_alloc(SDP_UINT8, &chan);
287 proto[1] = sdp_list_append(proto[1], channel); 298 proto[1] = sdp_list_append(proto[1], channel);
288 apseq = sdp_list_append(apseq, proto[1]); 299 apseq = sdp_list_append(apseq, proto[1]);
289 300
290 sdp_uuid16_create(&obex_uuid, OBEX_UUID); 301 sdp_uuid16_create(&obex_uuid, OBEX_UUID);
291 proto[2] = sdp_list_append(0, &obex_uuid); 302 proto[2] = sdp_list_append(0, &obex_uuid);
292 apseq = sdp_list_append(apseq, proto[2]); 303 apseq = sdp_list_append(apseq, proto[2]);
293 304
294 aproto = sdp_list_append(0, apseq); 305 aproto = sdp_list_append(0, apseq);
295 sdp_set_access_protos(&record, aproto); 306 sdp_set_access_protos(&record, aproto);
296 307
297 for (i = 0; i < sizeof(formats); i++) 308 for (i = 0; i < sizeof(formats); i++)
298 { 309 {
299 dtds[i] = &dtd; 310 dtds[i] = &dtd;
300 values[i] = &formats[i]; 311 values[i] = &formats[i];
301 } 312 }
302 sflist = sdp_seq_alloc(dtds, values, sizeof(formats)); 313 sflist = sdp_seq_alloc(dtds, values, sizeof(formats));
303 sdp_attr_add(&record, SDP_ATTR_SUPPORTED_FORMATS_LIST, sflist); 314 sdp_attr_add(&record, SDP_ATTR_SUPPORTED_FORMATS_LIST, sflist);
304 315
305 sdp_set_info_attr(&record, name, 0, 0); 316 sdp_set_info_attr(&record, name, 0, 0);
306 317
@@ -331,188 +342,180 @@ int ObexServer::initObex(void)
331 if (m_obex) 342 if (m_obex)
332 return 0; 343 return 0;
333 m_obex = ::OBEX_Init(transport, obex_event, 0); 344 m_obex = ::OBEX_Init(transport, obex_event, 0);
334 if (!m_obex) { 345 if (!m_obex) {
335 printf("OBEX initialization error %d\n", errno); 346 printf("OBEX initialization error %d\n", errno);
336 return -1; 347 return -1;
337 } 348 }
338 if (transport == OBEX_TRANS_BLUETOOTH) { 349 if (transport == OBEX_TRANS_BLUETOOTH) {
339 ::BtOBEX_ServerRegister(m_obex, NULL, channel); 350 ::BtOBEX_ServerRegister(m_obex, NULL, channel);
340 m_session = addOpushSvc(channel, "OBEX Object Push"); 351 m_session = addOpushSvc(channel, "OBEX Object Push");
341 if (!m_session) { 352 if (!m_session) {
342 printf("OBEX registration error %d\n", errno); 353 printf("OBEX registration error %d\n", errno);
343 ::OBEX_Cleanup(m_obex); 354 ::OBEX_Cleanup(m_obex);
344 m_obex = NULL; 355 m_obex = NULL;
345 return -1; 356 return -1;
346 } 357 }
347 } else if (transport == OBEX_TRANS_IRDA) 358 } else if (transport == OBEX_TRANS_IRDA)
348 ::IrOBEX_ServerRegister(m_obex, "OBEX"); 359 ::IrOBEX_ServerRegister(m_obex, "OBEX");
349 return 0; 360 return 0;
350} 361}
351 362
352bool ObexServer::start(RunMode runmode, Communication comm) 363bool ObexServer::start(RunMode runmode, Communication comm)
353{ 364{
354 if ( runs ) 365 if ( runs )
355 { 366 {
356 return false; // cannot start a process that is already running 367 return false; // cannot start a process that is already running
357 // or if no executable has been assigned 368 // or if no executable has been assigned
358 } 369 }
359 run_mode = runmode; 370 run_mode = runmode;
360 status = 0; 371 status = 0;
361 372
362 if ( !setupCommunication( comm ) ) 373 if ( !setupCommunication( comm ) )
363 qWarning( "Could not setup Communication!" ); 374 qWarning( "Could not setup Communication!" );
364 375
365 // We do this in the parent because if we do it in the child process 376 // We do this in the parent because if we do it in the child process
366 // gdb gets confused when the application runs from gdb. 377 // gdb gets confused when the application runs from gdb.
367 uid_t uid = getuid(); 378 uid_t uid = getuid();
368 gid_t gid = getgid(); 379 gid_t gid = getgid();
369#ifdef HAVE_INITGROUPS 380#ifdef HAVE_INITGROUPS
370 381
371 struct passwd *pw = getpwuid( uid ); 382 struct passwd *pw = getpwuid( uid );
372#endif 383#endif
373 384
374 int fd[ 2 ]; 385 int fd[ 2 ];
375 if ( 0 > pipe( fd ) ) 386 if ( 0 > pipe( fd ) )
376 { 387 {
377 fd[ 0 ] = fd[ 1 ] = 0; // Pipe failed.. continue 388 fd[ 0 ] = fd[ 1 ] = 0; // Pipe failed.. continue
378 } 389 }
379 390
380 runs = true; 391 runs = true;
381 392
382 QApplication::flushX(); 393 QApplication::flushX();
383 394
384 // WABA: Note that we use fork() and not vfork() because 395 // WABA: Note that we use fork() and not vfork() because
385 // vfork() has unclear semantics and is not standardized. 396 // vfork() has unclear semantics and is not standardized.
386 pid_ = fork(); 397 pid_ = fork();
387 398
388 if ( 0 == pid_ ) 399 if ( 0 == pid_ )
389 { 400 {
390 if ( fd[ 0 ] ) 401 if ( fd[ 0 ] )
391 close( fd[ 0 ] ); 402 close( fd[ 0 ] );
392 if ( !runPrivileged() ) 403 if ( !runPrivileged() )
393 { 404 {
394 setgid( gid ); 405 setgid( gid );
395#if defined( HAVE_INITGROUPS) 406#if defined( HAVE_INITGROUPS)
396 407
397 if ( pw ) 408 if ( pw )
398 initgroups( pw->pw_name, pw->pw_gid ); 409 initgroups( pw->pw_name, pw->pw_gid );
399#endif 410#endif
400 411
401 setuid( uid ); 412 setuid( uid );
402 } 413 }
403 // The child process 414 // The child process
404 if ( !commSetupDoneC() ) 415 if ( !commSetupDoneC() )
405 qWarning( "Could not finish comm setup in child!" ); 416 qWarning( "Could not finish comm setup in child!" );
406 417
407 setupEnvironment(); 418 setupEnvironment();
408 419
409 // Matthias 420 // Matthias
410 if ( run_mode == DontCare ) 421 if ( run_mode == DontCare )
411 setpgid( 0, 0 ); 422 setpgid( 0, 0 );
412 // restore default SIGPIPE handler (Harri) 423 // restore default SIGPIPE handler (Harri)
413 struct sigaction act; 424 struct sigaction act;
414 sigemptyset( &( act.sa_mask ) ); 425 sigemptyset( &( act.sa_mask ) );
415 sigaddset( &( act.sa_mask ), SIGPIPE ); 426 sigaddset( &( act.sa_mask ), SIGPIPE );
416 act.sa_handler = SIG_DFL; 427 act.sa_handler = SIG_DFL;
417 act.sa_flags = 0; 428 act.sa_flags = 0;
418 sigaction( SIGPIPE, &act, 0L ); 429 sigaction( SIGPIPE, &act, 0L );
419 430
420 // We set the close on exec flag. 431 // We set the close on exec flag.
421 // Closing of fd[1] indicates that the execvp succeeded! 432 // Closing of fd[1] indicates that the execvp succeeded!
422 if ( fd[ 1 ] ) 433 if ( fd[ 1 ] )
423 fcntl( fd[ 1 ], F_SETFD, FD_CLOEXEC ); 434 fcntl( fd[ 1 ], F_SETFD, FD_CLOEXEC );
424 435
425 if (initObex() == 0) { 436 if (initObex() == 0) {
426 do { 437 do {
427 int result; //Connection result
428 if ( fd[ 1 ] ) { 438 if ( fd[ 1 ] ) {
429 ::close(fd[1]); 439 ::close(fd[1]);
430 fd[1] = 0; 440 fd[1] = 0;
431 } 441 }
432 if ((result = OBEX_HandleInput(m_obex, 60)) < 0) { 442 if (OBEX_HandleInput(m_obex, 10) < 0)
433 if (errno != ECONNRESET) { 443 _exit(0);
434 printf("OBEX_HandleInput error %d\n", errno);
435 fflush(stdout);
436 _exit(-1);
437 }
438 else
439 _exit(0);
440 }
441 } while(1); 444 } while(1);
442 } 445 }
443 char resultByte = 1; 446 char resultByte = 1;
444 if ( fd[ 1 ] ) 447 if ( fd[ 1 ] )
445 write( fd[ 1 ], &resultByte, 1 ); 448 write( fd[ 1 ], &resultByte, 1 );
446 _exit( -1 ); 449 _exit( -1 );
447 } 450 }
448 else if ( -1 == pid_ ) 451 else if ( -1 == pid_ )
449 { 452 {
450 // forking failed 453 // forking failed
451 454
452 runs = false; 455 runs = false;
453 return false; 456 return false;
454 } 457 }
455 else 458 else
456 { 459 {
457 if ( fd[ 1 ] ) 460 if ( fd[ 1 ] )
458 close( fd[ 1 ] ); 461 close( fd[ 1 ] );
459 // the parent continues here 462 // the parent continues here
460 463
461 // Discard any data for stdin that might still be there 464 // Discard any data for stdin that might still be there
462 input_data = 0; 465 input_data = 0;
463 466
464 // Check whether client could be started. 467 // Check whether client could be started.
465 if ( fd[ 0 ] ) 468 if ( fd[ 0 ] )
466 for ( ;; ) 469 for ( ;; )
467 { 470 {
468 char resultByte; 471 char resultByte;
469 int n = ::read( fd[ 0 ], &resultByte, 1 ); 472 int n = ::read( fd[ 0 ], &resultByte, 1 );
470 if ( n == 1 ) 473 if ( n == 1 )
471 { 474 {
472 // Error 475 // Error
473 runs = false; 476 runs = false;
474 close( fd[ 0 ] ); 477 close( fd[ 0 ] );
475 pid_ = 0; 478 pid_ = 0;
476 return false; 479 return false;
477 } 480 }
478 if ( n == -1 ) 481 if ( n == -1 )
479 { 482 {
480 if ( ( errno == ECHILD ) || ( errno == EINTR ) ) 483 if ( ( errno == ECHILD ) || ( errno == EINTR ) )
481 continue; // Ignore 484 continue; // Ignore
482 } 485 }
483 break; // success 486 break; // success
484 } 487 }
485 if ( fd[ 0 ] ) 488 if ( fd[ 0 ] )
486 close( fd[ 0 ] ); 489 close( fd[ 0 ] );
487 490
488 if ( !commSetupDoneP() ) // finish communication socket setup for the parent 491 if ( !commSetupDoneP() ) // finish communication socket setup for the parent
489 qWarning( "Could not finish comm setup in parent!" ); 492 qWarning( "Could not finish comm setup in parent!" );
490 493
491 if ( run_mode == Block ) 494 if ( run_mode == Block )
492 { 495 {
493 commClose(); 496 commClose();
494 497
495 // The SIGCHLD handler of the process controller will catch 498 // The SIGCHLD handler of the process controller will catch
496 // the exit and set the status 499 // the exit and set the status
497 while ( runs ) 500 while ( runs )
498 { 501 {
499 OProcessController::theOProcessController-> 502 OProcessController::theOProcessController->
500 slotDoHousekeeping( 0 ); 503 slotDoHousekeeping( 0 );
501 } 504 }
502 runs = FALSE; 505 runs = FALSE;
503 emit processExited( this ); 506 emit processExited( this );
504 } 507 }
505 } 508 }
506 return true; 509 return true;
507} 510}
508 511
509/* 512/*
510 * Stop forwarding process 513 * Stop forwarding process
511 */ 514 */
512int ObexServer::stop() 515int ObexServer::stop()
513{ 516{
514 kill(SIGTERM); 517 kill(SIGTERM);
515 return 0; 518 return 0;
516} 519}
517 520
518//eof 521//eof