summaryrefslogtreecommitdiff
path: root/core
Side-by-side diff
Diffstat (limited to 'core') (more/less context) (ignore whitespace changes)
-rw-r--r--core/obex/obex.pro4
-rw-r--r--core/obex/obexserver.cpp36
2 files changed, 23 insertions, 17 deletions
diff --git a/core/obex/obex.pro b/core/obex/obex.pro
index 05118ab..2372d12 100644
--- a/core/obex/obex.pro
+++ b/core/obex/obex.pro
@@ -1,24 +1,24 @@
TEMPLATE = lib
CONFIG += qt warn_on
HEADERS = obex.h obexhandler.h obexsend.h receiver.h obeximpl.h obexbase.h obexserver.h
SOURCES = obex.cpp obexsend.cpp obexhandler.cpp receiver.cpp obeximpl.cpp obexbase.cpp obexserver.cpp
TARGET = opieobex
DESTDIR = $(OPIEDIR)/plugins/obex
INTERFACES = obexsendbase.ui
INCLUDEPATH += $(OPIEDIR)/include $(OPIEDIR)/core/launcher
DEPENDPATH +=
-LIBS += -lqpe -lopiecore2
+LIBS += -lqpe -lopiecore2 -lopenobex
VERSION = 0.0.4
include( $(OPIEDIR)/include.pro )
target.path = $$prefix/plugins/applets
#FIXME: These parameters are used if bluetooth is used
CONFTEST = $$system( echo $CONFIG_LIBOPIETOOTH )
contains( CONFTEST, y ){
HEADERS += btobex.h
SOURCES += btobex.cpp
INCLUDEPATH += $(OPIEDIR)/noncore/net/opietooth/lib
-LIBS += -lopietooth1 -lbluetooth -lopenobex
+LIBS += -lopietooth1 -lbluetooth
DEFINES += BLUETOOTH
}
diff --git a/core/obex/obexserver.cpp b/core/obex/obexserver.cpp
index f1fb205..59fcb0f 100644
--- a/core/obex/obexserver.cpp
+++ b/core/obex/obexserver.cpp
@@ -1,518 +1,524 @@
/*
               =. This file is part of the OPIE Project
             .=l. Copyright (c) 2002 Maximilian Reiss <max.reiss@gmx.de>
           .>+-=
 _;:,     .>    :=|. This library is free software; you can
.> <,   >  .   <= redistribute it and/or modify it under
:=1 )Y*s>-.--   : the terms of the GNU Library General Public
.="- .-=="i,     .._ License as published by the Free Software
 - .   .-<_>     .<> Foundation; version 2 of the License.
     ._= =}       :
    .%+i>       _;_.
    .i_,=:_.      -<s. This library is distributed in the hope that
     +  .  -:.       = it will be useful, but WITHOUT ANY WARRANTY;
    : ..    .:,     . . . without even the implied warranty of
    =_        +     =;=| MERCHANTABILITY or FITNESS FOR A
  _.=:.       :    :=>: PARTICULAR PURPOSE. See the GNU
..}^=.=       =       ; Library General Public License for more
++=   -.     .     .: details.
 :     =  ...= . :.=-
 -.   .:....=;==+<; You should have received a copy of the GNU
  -_. . .   )=.  = Library General Public License along with
  --        :-= this library; see the file COPYING.LIB.
If not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
/*
* The OBEX server class implementation
* Based on OBEX server from GPE (thanks, guys)
*/
#include "obexserver.h"
#include <unistd.h>
#include <opie2/odebug.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <qapplication.h>
#include <opie2/oprocctrl.h>
#include <qstring.h>
#include <qfile.h>
using namespace Opie::Core;
using namespace Opie::Core::Internal;
using namespace OpieObex;
ObexServer::ObexServer(int trans) :
OProcess(tr("ObexServer"), 0, "ObexServer")
{
transport = trans;
m_obex = NULL;
}
ObexServer::~ObexServer()
{
stop();
}
/**
* Function handles the file received
* @param name the file name
* @param data the file data
* @param data_len the data length
* @return 0 on success -1 on error
*/
static int file_received(uint8_t* name, const uint8_t* data, size_t data_len)
{
QString path("/tmp/");
path += (char*)name;
QFile out(path);
int err = 0;
if (!out.open(IO_Raw | IO_ReadWrite | IO_Truncate)) {
printf("File %s open error %d\n", (const char*)path, errno);
err = -1;
goto out;
}
if (out.writeBlock((const char*)data, data_len) < 0) {
printf("File %s write error %d\n", (const char*)path, errno);
err = -1;
goto out;
}
out:
out.close();
if (err == 0) {
printf("Wrote %s (%d bytes)\n", (const char*)path, data_len);
fflush(stdout);
}
return err;
}
/**
* Function handles the situation when the PUT request has been done
* @param handle OBEX connection handle
* @param object OBEX object itself
*/
static int put_done(obex_t* handle, obex_object_t* object)
{
obex_headerdata_t hv; //Received file header
uint8_t hi; //Type of the request
uint32_t hlen; //File (file name) length
int err = 0;
const uint8_t *body = NULL;
int body_len = 0;
uint8_t* name = NULL;
while (OBEX_ObjectGetNextHeader (handle, object, &hi, &hv, &hlen)) {
switch(hi) {
case OBEX_HDR_BODY:
body = hv.bs;
body_len = hlen;
break;
case OBEX_HDR_NAME:
name = new uint8_t[(hlen / 2) + 1];
OBEX_UnicodeToChar(name, hv.bs, hlen);
break;
default:
break;
}
}
if (body)
err = file_received(name, body, body_len);
if (name)
delete[] name;
return err;
}
/**
* Function handles OBEX request
* @param handle OBEX connection handle
* @param object OBEX object itself
* @param mode
* @param event event code
* @param cmd OBEX command itself
*/
static void handle_request (obex_t* handle, obex_object_t* object,
int event, int cmd)
{
(void)event;
switch(cmd) {
case OBEX_CMD_SETPATH:
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_PUT:
if (put_done (handle, object) < 0)
OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR,
OBEX_RSP_INTERNAL_SERVER_ERROR);
else
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_CONNECT:
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_DISCONNECT:
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
break;
default:
printf("Denied %02x request\n", cmd);
fflush(stdout);
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
OBEX_RSP_NOT_IMPLEMENTED);
break;
}
}
/**
* Function handles OBEX event when a client is connected to the server
* @param handle OBEX connection handle
* @param object OBEX object itself
* @param mode
* @param event event code
* @param obex_cmd OBEX command itself
* @param obex_rsp OBEX responce
*/
static void obex_conn_event (obex_t *handle, obex_object_t *object,
int mode, int event, int obex_cmd, int obex_rsp)
{
(void)mode;
(void)obex_rsp;
switch(event) {
case OBEX_EV_REQHINT:
switch(obex_cmd) {
case OBEX_CMD_PUT:
case OBEX_CMD_CONNECT:
case OBEX_CMD_DISCONNECT:
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
break;
default:
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
OBEX_RSP_NOT_IMPLEMENTED);
break;
}
break;
case OBEX_EV_REQ:
/* Comes when a server-request has been received. */
handle_request (handle, object, event, obex_cmd);
break;
-
+ case OBEX_EV_REQDONE:
+ switch(obex_cmd) {
+ case OBEX_CMD_PUT:
+ case OBEX_CMD_CONNECT:
+ break;
+ case OBEX_CMD_DISCONNECT:
+ OBEX_TransportDisconnect(handle);
+ _exit(0);
+ break;
+ default:
+ break;
+ }
+ break;
case OBEX_EV_LINKERR:
break;
}
}
/**
* Function handles OBEX event
* @param handle OBEX connection handle
* @param object OBEX object itself
* @param mode
* @param event event code
* @param obex_cmd OBEX command itself
* @param obex_rsp OBEX responce
*/
static void obex_event (obex_t* handle, obex_object_t* object, int mode,
int event, int obex_cmd, int obex_rsp)
{
obex_t *obex; //OBEX connection handle
switch (event) {
case OBEX_EV_ACCEPTHINT:
obex = OBEX_ServerAccept (handle, obex_conn_event, NULL);
break;
default:
obex_conn_event(handle, object, mode, event, obex_cmd, obex_rsp);
}
}
/**
* Function registers OBEX push service on a specified channel
* Based on The same function from GPE.
* @param session SDP session
* @param chan channel to listen
* @name name to show
*/
sdp_session_t* ObexServer::addOpushSvc(uint8_t chan, const char* name)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, opush_uuid, l2cap_uuid, rfcomm_uuid, obex_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_record_t record;
sdp_data_t *channel;
uint8_t formats[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
//uint8_t formats[] = { 0xff };
void *dtds[sizeof(formats)], *values[sizeof(formats)];
unsigned int i;
uint8_t dtd = SDP_UINT8;
sdp_data_t *sflist;
int err = 0;
sdp_session_t* lsession = 0;
memset((void *)&record, 0, sizeof(sdp_record_t));
record.handle = 0xffffffff;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(&record, root);
sdp_uuid16_create(&opush_uuid, OBEX_OBJPUSH_SVCLASS_ID);
svclass_id = sdp_list_append(0, &opush_uuid);
sdp_set_service_classes(&record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, OBEX_OBJPUSH_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(&record, pfseq);
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append(0, &l2cap_uuid);
apseq = sdp_list_append(0, proto[0]);
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
proto[1] = sdp_list_append(0, &rfcomm_uuid);
channel = sdp_data_alloc(SDP_UINT8, &chan);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(apseq, proto[1]);
sdp_uuid16_create(&obex_uuid, OBEX_UUID);
proto[2] = sdp_list_append(0, &obex_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(&record, aproto);
for (i = 0; i < sizeof(formats); i++)
{
dtds[i] = &dtd;
values[i] = &formats[i];
}
sflist = sdp_seq_alloc(dtds, values, sizeof(formats));
sdp_attr_add(&record, SDP_ATTR_SUPPORTED_FORMATS_LIST, sflist);
sdp_set_info_attr(&record, name, 0, 0);
// connect to the local SDP server, register the service record, and
// disconnect
lsession = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
if (lsession == NULL)
goto errout;
err = sdp_record_register(lsession, &record, 0);
if (err) {
sdp_close(lsession);
lsession = NULL;
}
errout:
sdp_data_free(channel);
sdp_list_free(proto[0], 0);
sdp_list_free(proto[1], 0);
sdp_list_free(proto[2], 0);
sdp_list_free(apseq, 0);
sdp_list_free(aproto, 0);
return lsession;
}
int ObexServer::initObex(void)
{
int channel = 10; //Channel on which we do listen
if (m_obex)
return 0;
m_obex = ::OBEX_Init(transport, obex_event, 0);
if (!m_obex) {
printf("OBEX initialization error %d\n", errno);
return -1;
}
if (transport == OBEX_TRANS_BLUETOOTH) {
::BtOBEX_ServerRegister(m_obex, NULL, channel);
m_session = addOpushSvc(channel, "OBEX Object Push");
if (!m_session) {
printf("OBEX registration error %d\n", errno);
::OBEX_Cleanup(m_obex);
m_obex = NULL;
return -1;
}
} else if (transport == OBEX_TRANS_IRDA)
::IrOBEX_ServerRegister(m_obex, "OBEX");
return 0;
}
bool ObexServer::start(RunMode runmode, Communication comm)
{
if ( runs )
{
return false; // cannot start a process that is already running
// or if no executable has been assigned
}
run_mode = runmode;
status = 0;
if ( !setupCommunication( comm ) )
qWarning( "Could not setup Communication!" );
// We do this in the parent because if we do it in the child process
// gdb gets confused when the application runs from gdb.
uid_t uid = getuid();
gid_t gid = getgid();
#ifdef HAVE_INITGROUPS
struct passwd *pw = getpwuid( uid );
#endif
int fd[ 2 ];
if ( 0 > pipe( fd ) )
{
fd[ 0 ] = fd[ 1 ] = 0; // Pipe failed.. continue
}
runs = true;
QApplication::flushX();
// WABA: Note that we use fork() and not vfork() because
// vfork() has unclear semantics and is not standardized.
pid_ = fork();
if ( 0 == pid_ )
{
if ( fd[ 0 ] )
close( fd[ 0 ] );
if ( !runPrivileged() )
{
setgid( gid );
#if defined( HAVE_INITGROUPS)
if ( pw )
initgroups( pw->pw_name, pw->pw_gid );
#endif
setuid( uid );
}
// The child process
if ( !commSetupDoneC() )
qWarning( "Could not finish comm setup in child!" );
setupEnvironment();
// Matthias
if ( run_mode == DontCare )
setpgid( 0, 0 );
// restore default SIGPIPE handler (Harri)
struct sigaction act;
sigemptyset( &( act.sa_mask ) );
sigaddset( &( act.sa_mask ), SIGPIPE );
act.sa_handler = SIG_DFL;
act.sa_flags = 0;
sigaction( SIGPIPE, &act, 0L );
// We set the close on exec flag.
// Closing of fd[1] indicates that the execvp succeeded!
if ( fd[ 1 ] )
fcntl( fd[ 1 ], F_SETFD, FD_CLOEXEC );
if (initObex() == 0) {
+ if ( fd[ 1 ] ) {
+ ::close(fd[1]);
+ fd[1] = 0;
+ }
do {
- int result; //Connection result
- if ( fd[ 1 ] ) {
- ::close(fd[1]);
- fd[1] = 0;
- }
- if ((result = OBEX_HandleInput(m_obex, 60)) < 0) {
- if (errno != ECONNRESET) {
- printf("OBEX_HandleInput error %d\n", errno);
- fflush(stdout);
- _exit(-1);
- }
- else
- _exit(0);
- }
+ if (OBEX_HandleInput(m_obex, 60) < 0) {
+ fprintf(stderr,"failed to OBEX_HandleInput(), errno=%d\n",errno);
+ _exit(errno?errno:-1);
+ }
} while(1);
}
char resultByte = 1;
if ( fd[ 1 ] )
write( fd[ 1 ], &resultByte, 1 );
_exit( -1 );
}
else if ( -1 == pid_ )
{
// forking failed
runs = false;
return false;
}
else
{
if ( fd[ 1 ] )
close( fd[ 1 ] );
// the parent continues here
// Discard any data for stdin that might still be there
input_data = 0;
// Check whether client could be started.
if ( fd[ 0 ] )
for ( ;; )
{
char resultByte;
int n = ::read( fd[ 0 ], &resultByte, 1 );
if ( n == 1 )
{
// Error
runs = false;
close( fd[ 0 ] );
pid_ = 0;
return false;
}
if ( n == -1 )
{
if ( ( errno == ECHILD ) || ( errno == EINTR ) )
continue; // Ignore
}
break; // success
}
if ( fd[ 0 ] )
close( fd[ 0 ] );
if ( !commSetupDoneP() ) // finish communication socket setup for the parent
qWarning( "Could not finish comm setup in parent!" );
if ( run_mode == Block )
{
commClose();
// The SIGCHLD handler of the process controller will catch
// the exit and set the status
while ( runs )
{
OProcessController::theOProcessController->
slotDoHousekeeping( 0 );
}
runs = FALSE;
emit processExited( this );
}
}
return true;
}
/*
* Stop forwarding process
*/
int ObexServer::stop()
{
kill(SIGTERM);
return 0;
}
//eof