//
// Add more data to stream.
//
static int writestream(obex_t *handle, obex_object_t *object)
{
int actual;
obexsrv_t *srv = OBEX_GetUserData(handle);
obex_headerdata_t hv;
actual = read(srv->sfd, srv->buf, OBEX_STREAM_CHUNK);
DBPRT("sent %d bytes\n", actual);
if(actual > 0) {
/* Read was ok! */
hv.bs = srv->buf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hv, actual, OBEX_FL_STREAM_DATA);
} else if(actual == 0) {
/* EOF */
hv.bs = srv->buf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATAEND);
} else {
/* Error */
hv.bs = NULL;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATA);
}
return actual;
}
/**
Add more data from memory to stream.
*/
static int cli_fillstream_from_memory(obexftp_client_t *cli, obex_object_t *object)
{
obex_headerdata_t hv;
int actual = cli->out_size - cli->out_pos;
if (actual > STREAM_CHUNK)
actual = STREAM_CHUNK;
DEBUG(3, "%s() Read %d bytes\n", __func__, actual);
if(actual > 0) {
/* Read was ok! */
hv.bs = (const uint8_t *) &cli->out_data[cli->out_pos];
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, actual, OBEX_FL_STREAM_DATA);
cli->out_pos += actual;
}
else if(actual == 0) {
/* EOF */
cli->out_data = NULL; /* dont free, isnt ours */
hv.bs = (const uint8_t *) &cli->out_data[cli->out_pos];
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATAEND);
}
else {
/* Error */
cli->out_data = NULL; /* dont free, isnt ours */
hv.bs = (const uint8_t *) NULL;
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATA);
}
return actual;
}
int obex_setpath(int od, const char *path, uint8_t flags)
{
unsigned char taildata[2] = { 0x00, 0x00 };
obex_t *handle = obex_handles[0];
struct obex_context *context;
char unicode[200];
int err, size;
obex_object_t *object;
obex_headerdata_t hd;
if (!(context = OBEX_GetUserData(handle)))
return -1;
if (context->state != OBEX_CONNECTED)
return -1;
if (context->mode != OBEX_IDLE)
return -1;
context->mode = OBEX_REQUEST;
if (!(object = OBEX_ObjectNew(handle, OBEX_CMD_SETPATH)))
return -1;
if (context->cid > 0) {
hd.bq4 = context->cid;
OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_CONNECTION, hd, 4, OBEX_FL_FIT_ONE_PACKET);
}
if (path) {
size = OBEX_CharToUnicode((uint8_t *) unicode, (uint8_t *) path, sizeof(unicode));
hd.bs = (uint8_t *) unicode;
OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_NAME, hd, size, OBEX_FL_FIT_ONE_PACKET);
}
taildata[0] = flags;
OBEX_ObjectSetNonHdrData(object, taildata, sizeof(taildata));
if ((err = OBEX_Request(handle, object)) < 0)
return err;
while (1) {
OBEX_HandleInput(handle, OBEX_TIMEOUT);
if (context->mode == OBEX_ERROR) {
err = -EIO;
break;
}
if (context->mode == OBEX_DONE)
break;
}
context->mode = OBEX_IDLE;
return err;
}
obex_object_t*
BuildObjFromFile(obex_t* handle, const char* filename)
{
obex_headerdata_t hdd;
uint8_t unicodebuf[200];
int namebuflen;
obex_object_t *object;
uint32_t creatorid = MEMO_PAD;
int filesize;
char* name = NULL;
uint8_t* buf;
buf = ReadEasily(filename, &filesize);
if (buf == NULL)
return NULL;
creatorid = MEMO_PAD;
name = strchr(filename, '.');
if (name) {
name++;
if (strcmp(name, "vcf") == 0) {
printf( "This is a Address Book file\n");
creatorid = ADDRESS_BOOK;
} else if (strcmp(name, "vcs") == 0) {
printf( "This is a Date Book file\n");
creatorid = DATE_BOOK;
} else if (strcmp(name, "txt") == 0) {
printf("This is a Memo pad file\n");
creatorid = MEMO_PAD;
} else if (strcmp(name, "prc") == 0) {
printf("This is a Pilot resource file\n");
creatorid = PILOT_RESOURCE;
}
}
object = OBEX_ObjectNew(handle, OBEX_CMD_PUT);
// makhtar
//namebuflen = OBEX_CharToUnicode(unicodebuf, (const uint8_t *)filename, sizeof(unicodebuf));
strcpy(unicodebuf, filename);
namebuflen = sizeof(unicodebuf);
hdd.bs = unicodebuf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_NAME, hdd, namebuflen, 0);
hdd.bq4 = filesize;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_LENGTH, hdd, sizeof(uint32_t), 0);
if (obexProtocolType != 1) {
hdd.bq4 = creatorid;
OBEX_ObjectAddHeader(handle, object, HEADER_CREATOR_ID, hdd, sizeof(uint32_t), 0);
}
hdd.bs = buf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY, hdd, filesize, 0);
free(buf);
return object;
}
PyObject *lightblueobex_filetostream(obex_t *obex, obex_object_t *obj, PyObject *fileobj, int bufsize)
{
const void *data;
Py_ssize_t datalen; /* or unsigned int? */
obex_headerdata_t hv;
PyObject *buf;
DEBUG("%s()\n", __func__);
if (fileobj == NULL) {
DEBUG("\tgiven file object is NULL\n");
hv.bs = NULL;
OBEX_ObjectAddHeader(obex, obj, OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_DATAEND);
return NULL;
}
buf = PyObject_CallMethod(fileobj, "read", "i", bufsize);
if (buf == NULL) {
if (PyErr_Occurred()) {
PyErr_Print();
PyErr_Clear(); /* let caller set exception */
}
DEBUG("\terror calling file object read()\n");
}
if (buf != NULL && !PyObject_CheckReadBuffer(buf)) {
DEBUG("\tfile object read() returned non-buffer object\n");
Py_DECREF(buf);
buf = NULL;
}
if (buf != NULL && PyObject_AsReadBuffer(buf, &data, &datalen) < 0) {
DEBUG("\terror reading file object contents\n");
Py_DECREF(buf);
buf = NULL;
}
if (buf == NULL) {
hv.bs = NULL;
OBEX_ObjectAddHeader(obex, obj, OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_DATAEND);
return NULL;
}
hv.bs = (uint8_t*)data;
if (OBEX_ObjectAddHeader(obex, obj, OBEX_HDR_BODY, hv, datalen,
(datalen == 0 ? OBEX_FL_STREAM_DATAEND : OBEX_FL_STREAM_DATA)) < 0) {
DEBUG("\terror adding body data\n");
Py_DECREF(buf);
buf = NULL;
}
return buf;
}
void obexsrv_connect(obex_t *handle, obex_object_t *object)
{
obex_headerdata_t hv;
uint8_t hi;
int hlen;
uint8_t *nonhdrdata;
obex_target_t target = {0, NULL};
obexsrv_t *srv = OBEX_GetUserData(handle);
int err;
DBPRT("");
if(OBEX_ObjectGetNonHdrData(object, &nonhdrdata) == 4) {
#ifdef CONFIG_AFFIX_DEBUG
obex_connect_hdr_t *hdr = (obex_connect_hdr_t*)nonhdrdata;
DBPRT("Version: 0x%02x. Flags: 0x%02x OBEX packet length:%d",
hdr->version, hdr->flags, ntohs(hdr->mtu));
#endif
} else {
BTERROR("Invalid packet content.");
}
while(OBEX_ObjectGetNextHeader(handle, object, &hi, &hv, &hlen)) {
switch (hi) {
case OBEX_HDR_TARGET:
target.data = (void*)hv.bs;
target.len = hlen;
if (hlen == 16)
DBPRT("got TARGET. uuid_t: %08X-%04X-%04X-%04X-%08X%04X",
*(uint32_t *)&target.data[0], *(uint16_t *)&target.data[4],
*(uint16_t *)&target.data[6], *(uint16_t *)&target.data[8],
*(uint32_t *)&target.data[10], *(uint16_t *)&target.data[14]);
else
DBPRT("got TARGET. unknown fmt");
break;
default:
DBPRT(" Skipped header %02x", hi);
break;
}
}
// call handler
err = srv->connect(srv, &target);
if (err < 0) {
/* error */
OBEX_ObjectSetRsp(object, OBEX_RSP_INTERNAL_SERVER_ERROR, OBEX_RSP_INTERNAL_SERVER_ERROR);
} else {
OBEX_ObjectSetRsp(object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
if (target.data) {
hv.bq4 = err; /* set connection id */
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_CONNECTION, hv, 4, 0);
hv.bs = target.data;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_WHO, hv, target.len, 0);
}
}
}
int obex_delete(obex_t *handle, const char *name)
{
obex_context_t *context = OBEX_GetUserData(handle);
obex_object_t *object;
obex_headerdata_t hd;
int err;
g_return_val_if_fail(context != NULL, -1);
if (context->state != OBEX_OPEN && context->state != OBEX_CONNECT
&& context->state != OBEX_CONNECTED)
return -ENOTCONN;
object = OBEX_ObjectNew(handle, OBEX_CMD_PUT);
if (!object)
return -ENOMEM;
if (context->cid != CID_INVALID) {
hd.bq4 = context->cid;
OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_CONNECTION, hd, 4, OBEX_FL_FIT_ONE_PACKET);
}
if (name) {
int len, ulen = (strlen(name) + 1) * 2;
uint8_t *unicode = malloc(ulen);
if (!unicode) {
OBEX_ObjectDelete(handle, object);
return -ENOMEM;
}
len = OBEX_CharToUnicode(unicode, (uint8_t *) name, ulen);
hd.bs = unicode;
err = OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_NAME, hd, len, OBEX_FL_FIT_ONE_PACKET);
if (err < 0) {
OBEX_ObjectDelete(handle, object);
free(unicode);
return err;
}
free(unicode);
}
err = obex_send_or_queue(handle, object);
if (err < 0)
OBEX_ObjectDelete(handle, object);
return err;
}
//
// Create an object from a file. Attach some info-headers to it
//
obex_object_t *build_object_from_file(obex_t *handle, const char *localname, const char *remotename)
{
obex_object_t *object = NULL;
obex_headerdata_t hdd;
uint8_t *ucname;
int ucname_len, size;
int i;
char lastmod[21*2] = {"1970-01-01T00:00:00Z"};
/* Get filesize and modification-time */
size = get_fileinfo(localname, lastmod);
object = OBEX_ObjectNew(handle, OBEX_CMD_PUT);
if(object == NULL)
return NULL;
ucname_len = strlen(remotename)*2 + 2;
ucname = malloc(ucname_len);
if(ucname == NULL)
goto err;
ucname_len = strcpy_utf8_to_unicode(ucname, remotename, ucname_len);
//ucname_len = OBEX_CharToUnicode(ucname, remotename, ucname_len);
//printf("ucname len %d\n", ucname_len);
//for(i=0; i< ucname_len; i++)
// printf("%d ", ucname[i]);
//printf("\n");
hdd.bs = ucname;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_NAME, hdd, ucname_len, 0);
free(ucname);
hdd.bq4 = size;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_LENGTH, hdd, sizeof(uint32_t), 0);
hdd.bs = NULL;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hdd, 0, OBEX_FL_STREAM_START);
DEBUG(4, "Lastmod = %s\n", lastmod);
return object;
err:
if(object != NULL)
OBEX_ObjectDelete(handle, object);
return NULL;
}
//
// Create an object from a file. Attach some info-headers to it
//
obex_object_t *build_object_from_file(obex_t *handle, const char *localname, const char *remotename)
{
obex_object_t *object = NULL;
obex_headerdata_t hdd;
uint8_t *ucname;
int ucname_len, size;
char lastmod[21*2] = {"1970-01-01T00:00:00Z"};
/* Get filesize and modification-time */
size = get_fileinfo(localname, lastmod);
object = OBEX_ObjectNew(handle, OBEX_CMD_PUT);
if(object == NULL)
return NULL;
ucname_len = strlen(remotename)*2 + 2;
ucname = malloc(ucname_len);
if(ucname == NULL)
goto err;
ucname_len = OBEX_CharToUnicode(ucname, remotename, ucname_len);
hdd.bs = ucname;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_NAME, hdd, ucname_len, 0);
free(ucname);
hdd.bq4 = size;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_LENGTH, hdd, sizeof(uint32_t), 0);
#if 0
/* Win2k excpects this header to be in unicode. I suspect this in
incorrect so this will have to wait until that's investigated */
hdd.bs = lastmod;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_TIME, hdd, strlen(lastmod)+1, 0);
#endif
hdd.bs = NULL;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hdd, 0, OBEX_FL_STREAM_START);
DEBUG(4, "Lastmod = %s\n", lastmod);
return object;
err:
if(object != NULL)
OBEX_ObjectDelete(handle, object);
return NULL;
}
int obex_connect(obex_t *handle, const unsigned char *target, size_t size)
{
obex_context_t *context = OBEX_GetUserData(handle);
obex_object_t *object;
obex_headerdata_t hd;
int err, ret;
g_return_val_if_fail(context != NULL, -1);
if (context->state != OBEX_OPEN && context->state != OBEX_CLOSED)
return -EISCONN;
object = OBEX_ObjectNew(handle, OBEX_CMD_CONNECT);
if (!object)
return -ENOMEM;
if (target) {
hd.bs = target;
err = OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_TARGET, hd, size, OBEX_FL_FIT_ONE_PACKET);
if (err < 0) {
OBEX_ObjectDelete(handle, object);
return err;
}
}
context->state = OBEX_CONNECT;
ret = obex_send_or_queue(handle, object);
if (ret < 0)
OBEX_ObjectDelete(handle, object);
return ret;
}
static int lightblueobex_add4byteheader(obex_t *obex, obex_object_t *obj, uint8_t hi, PyObject *value)
{
obex_headerdata_t hv;
uint32_t intvalue;
DEBUG("%s()\n", __func__);
if (value == NULL)
return -1;
if (PyInt_Check(value)) {
intvalue = PyInt_AsLong(value);
if (PyErr_Occurred()) {
DEBUG("\tcan't convert header 0x%02x int value to long", hi);
PyErr_Clear();
return -1;
}
} else if (PyLong_Check(value)) {
intvalue = PyLong_AsUnsignedLong(value);
if (PyErr_Occurred()) {
DEBUG("\tcan't convert header 0x%02x long value to long", hi);
PyErr_Clear();
return -1;
}
} else {
DEBUG("\theader value for id 0x%02x must be int or long, was %s\n",
hi, value->ob_type->tp_name);
return -1;
}
hv.bq4 = intvalue;
return OBEX_ObjectAddHeader(obex, obj, hi, hv, 4, OBEX_FL_FIT_ONE_PACKET);
}
//
// Do OBEX SetPath
//
static int ircp_setpath(ircp_client_t *cli, char *name, int up)
{
obex_object_t *object;
obex_headerdata_t hdd;
uint8_t setpath_nohdr_data[2] = {0,};
uint8_t *ucname;
int ucname_len;
int ret;
DEBUG(4, "%s\n", name);
object = OBEX_ObjectNew(cli->obexhandle, OBEX_CMD_SETPATH);
if(up) {
setpath_nohdr_data[0] = 1;
}
else {
ucname_len = strlen(name)*2 + 2;
ucname = malloc(ucname_len);
if(ucname == NULL) {
OBEX_ObjectDelete(cli->obexhandle, object);
return -1;
}
ucname_len = OBEX_CharToUnicode(ucname, (uint8_t *) name, ucname_len);
hdd.bs = ucname;
OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_NAME, hdd, ucname_len, 0);
free(ucname);
}
OBEX_ObjectSetNonHdrData(object, setpath_nohdr_data, 2);
ret = cli_sync_request(cli, object);
return ret;
}
/**
Disconnect this ObexFTP client by sending an OBEX DISCONNECT request.
\param cli an obexftp_client_t created by obexftp_open().
\return the result of the DISCONNECT request
*/
int obexftp_disconnect(obexftp_client_t *cli)
{
obex_object_t *object;
obex_headerdata_t hv;
int ret;
DEBUG(3, "%s()\n", __func__);
return_val_if_fail(cli != NULL, -EINVAL);
cli->infocb(OBEXFTP_EV_DISCONNECTING, "", 0, cli->infocb_data);
object = OBEX_ObjectNew(cli->obexhandle, OBEX_CMD_DISCONNECT);
if(cli->connection_id != 0xffffffff) {
hv.bq4 = cli->connection_id;
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_CONNECTION,
hv, sizeof(uint32_t), OBEX_FL_FIT_ONE_PACKET);
}
ret = cli_sync_request(cli, object);
if(ret < 0)
cli->infocb(OBEXFTP_EV_ERR, "disconnect", 0, cli->infocb_data);
else
cli->infocb(OBEXFTP_EV_OK, "", 0, cli->infocb_data);
/* don't -- obexftp_close will handle this with OBEX_Cleanup */
/* OBEX_TransportDisconnect(cli->obexhandle); */
return ret;
}
static void connect_server(obex_t *handle, obex_object_t *object)
{
obex_headerdata_t hv;
uint8_t hi;
uint32_t hlen;
uint8_t *target = NULL;
int target_len = 0;
//printf("%s()\n", __FUNCTION__);
while (OBEX_ObjectGetNextHeader(handle, object, &hi, &hv, &hlen)) {
switch(hi) {
case OBEX_HDR_TARGET:
if (0 < hlen)
{
if( (target = malloc(hlen))) {
target_len = hlen;
memcpy(target,hv.bs,target_len);
}
}
break;
default:
printf("%s() Skipped header %02x\n", __FUNCTION__, hi);
break;
}
}
OBEX_ObjectSetRsp(object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
hv.bq4 = connection_id;
if(OBEX_ObjectAddHeader(handle, object, OBEX_HDR_CONNECTION,
hv, sizeof(hv.bq4),
OBEX_FL_FIT_ONE_PACKET) < 0 ) {
fprintf(stderr, "Error adding header CONNECTION\n");
OBEX_ObjectDelete(handle, object);
return;
}
if (target && target_len) {
hv.bs = target;
if(OBEX_ObjectAddHeader(handle,object,OBEX_HDR_WHO,
hv,target_len,OBEX_FL_FIT_ONE_PACKET) < 0 ) {
fprintf(stderr, "Error adding header WHO\n");
OBEX_ObjectDelete(handle, object);
return;
}
free(target);
}
}
static char *get_named_object(obex_t *handle, char *name, int *len)
{
struct obex_state *state;
int req_done;
obex_object_t *obj;
obex_headerdata_t hd;
int size, i;
glong num;
state = OBEX_GetUserData(handle);
obj = OBEX_ObjectNew(handle, OBEX_CMD_GET);
hd.bq4 = state->connid;
size = 4;
OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_CONNECTION,
hd, size, OBEX_FL_FIT_ONE_PACKET);
hd.bs = (unsigned char *)g_utf8_to_utf16(name, strlen(name),
NULL, &num, NULL);
for (i=0; i<num; i++) {
uint16_t *wchar = (uint16_t*)&hd.bs[i*2];
*wchar = ntohs(*wchar);
}
size = (num+1) * sizeof(uint16_t);
OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_NAME, hd, size, OBEX_FL_FIT_ONE_PACKET);
if (OBEX_Request(handle, obj) < 0)
return NULL;
req_done = state->req_done;
while (state->req_done == req_done) {
OBEX_HandleInput(handle, 100);
}
if (state->body) {
*len = state->body_len;
state->body[state->body_len] = '\0';
} else {
*len = 0;
}
return state->body;
}
static int lightblueobex_addbytestreamheader(obex_t *obex, obex_object_t *obj, uint8_t hi, PyObject *bufObject)
{
obex_headerdata_t hv;
uint32_t hv_size;
DEBUG("%s()\n", __func__);
if (PyObject_AsReadBuffer(bufObject, (const void**)&hv.bs, (Py_ssize_t*)&hv_size) < 0) {
DEBUG("\theader value for id 0x%02x must be readable buffer\n", hi);
return -1;
}
return OBEX_ObjectAddHeader(obex, obj, hi, hv, hv_size, OBEX_FL_FIT_ONE_PACKET);
}
/**
Add more data from file to stream.
*/
static int cli_fillstream_from_file(obexftp_client_t *cli, obex_object_t *object)
{
obex_headerdata_t hv;
int actual;
DEBUG(3, "%s()\n", __func__);
actual = read(cli->fd, cli->stream_chunk, STREAM_CHUNK);
DEBUG(3, "%s() Read %d bytes\n", __func__, actual);
if(actual > 0) {
/* Read was ok! */
hv.bs = (const uint8_t *) cli->stream_chunk;
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, actual, OBEX_FL_STREAM_DATA);
}
else if(actual == 0) {
/* EOF */
(void) close(cli->fd);
cli->fd = -1;
hv.bs = (const uint8_t *) cli->stream_chunk;
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATAEND);
}
else {
/* Error */
(void) close(cli->fd);
cli->fd = -1;
hv.bs = (const uint8_t *) NULL;
(void) OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hv, 0, OBEX_FL_STREAM_DATA);
}
return actual;
}
static void obex_writestream(obex_t *handle, obex_object_t *object)
{
obex_context_t *context = OBEX_GetUserData(handle);
obex_headerdata_t hv;
if (context->data_length > 0) {
int send_size = context->data_length > context->tx_max ?
context->tx_max : context->data_length;
hv.bs = (uint8_t *) &context->buf[context->data_start];
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hv, send_size, OBEX_FL_STREAM_DATA);
context->counter += send_size;
context->data_length -= send_size;
if (context->data_length == 0)
context->data_start = 0;
else
context->data_start += send_size;
if (!context->close && context->data_length == 0) {
debug("OBEX_SuspendRequest");
OBEX_SuspendRequest(handle, object);
queue_event(context, OBEX_EV_STREAMEMPTY);
}
}
else {
if (context->counter < context->target_size)
debug("Sending stream end but only %d/%d bytes sent",
context->counter, context->target_size);
hv.bs = NULL;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_DATAEND);
}
}
static void
obexserver_receivedrequest(OBEXServer *self, obex_object_t *obj, int obex_cmd)
{
int respcode;
PyObject *respheaders;
DEBUG("%s()\n", __func__);
// Put requests are taken care of in obexserver_streamavailable()
if (obex_cmd == OBEX_CMD_PUT && self->hasbodydata) {
#ifdef LIGHTBLUEOBEX_SERVER_TEST
obex_headerdata_t hv;
hv.bq4 = self->puttotal;
OBEX_ObjectAddHeader(self->obex, obj, OBEX_HDR_LENGTH, hv, 4, 0);
#endif
return;
}
respheaders = obexserver_notifynewrequest(self, obj, obex_cmd, &respcode);
if (respheaders == NULL) {
obexserver_setresponse(self, obj, OBEX_RSP_INTERNAL_SERVER_ERROR, NULL);
} else {
int result;
result = obexserver_setresponse(self, obj, respcode, respheaders);
/* for Get requests, indicate we want OBEX_EV_STREAMEMPTY events */
if (result >= 0 && obex_cmd == OBEX_CMD_GET &&
(respcode == OBEX_RSP_CONTINUE || respcode == OBEX_RSP_SUCCESS)) {
obex_headerdata_t hv;
hv.bs = NULL;
OBEX_ObjectAddHeader(self->obex, obj, OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_START);
}
}
Py_XDECREF(respheaders);
}
//
// Add more data to stream.
//
static int cli_fillstream(ircp_client_t *cli, obex_object_t *object)
{
int actual;
obex_headerdata_t hdd;
DEBUG(4, "\n");
actual = read(cli->fd, cli->buf, STREAM_CHUNK);
DEBUG(4, "Read %d bytes\n", actual);
if(actual > 0) {
/* Read was ok! */
hdd.bs = cli->buf;
OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hdd, actual, OBEX_FL_STREAM_DATA);
}
else if(actual == 0) {
/* EOF */
hdd.bs = cli->buf;
close(cli->fd);
cli->fd = -1;
OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hdd, 0, OBEX_FL_STREAM_DATAEND);
}
else {
/* Error */
hdd.bs = NULL;
close(cli->fd);
cli->fd = -1;
OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_BODY,
hdd, 0, OBEX_FL_STREAM_DATA);
}
return actual;
}
static int lightblueobex_addunicodeheader(obex_t *obex, obex_object_t *obj, uint8_t hi, PyObject *utf16string)
{
obex_headerdata_t hv;
Py_ssize_t len = PyUnicode_GET_SIZE(utf16string);
uint8_t bytes[len+2];
DEBUG("%s()\n", __func__);
/* need to add 2-byte null terminator */
memcpy(bytes, (const uint8_t*)PyString_AsString(utf16string), len);
bytes[len] = 0x00;
bytes[len+1] = 0x00;
hv.bs = bytes;
return OBEX_ObjectAddHeader(obex, obj, (uint8_t)hi, hv, len+2,
OBEX_FL_FIT_ONE_PACKET);
}
int obex_connect(int od, int mode)
{
obex_t *handle = obex_handles[0];
struct obex_context *context;
int err;
obex_object_t *object;
obex_headerdata_t hd;
if (!(context = OBEX_GetUserData(handle)))
return -1;
if (!(object = OBEX_ObjectNew(handle, OBEX_CMD_CONNECT)))
return -1;
if (mode == OBEX_FILE_TRANSFER) {
hd.bs = target_ftseq;
if (OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_TARGET, hd, 16, OBEX_FL_FIT_ONE_PACKET) < 0) {
OBEX_ObjectDelete(handle, object);
return -1;
}
} else
context->cid = 0;
if ((err = OBEX_Request(handle, object)) < 0)
return err;
while (1) {
OBEX_HandleInput(handle, OBEX_TIMEOUT);
if (context->state == OBEX_CLOSED) {
err = -ENODEV;
break;
}
if (context->state == OBEX_CONNECTED)
break;
}
return err;
}
void smartpen_disconnect (obex_t *handle)
{
struct obex_state *state;
int req_done;
obex_object_t *obj;
obex_headerdata_t hd;
int size;
state = OBEX_GetUserData(handle);
obj = OBEX_ObjectNew(handle, OBEX_CMD_DISCONNECT);
hd.bq4 = state->connid;
size = 4;
OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_CONNECTION,
hd, size, OBEX_FL_FIT_ONE_PACKET);
if (OBEX_Request(handle, obj) < 0)
return;
req_done = state->req_done;
while (state->req_done == req_done) {
OBEX_HandleInput(handle, 100);
}
}
static void obex_event (obex_t *hdl, obex_object_t *obj, int mode,
int event, int obex_cmd, int obex_rsp)
{
struct obex_state *state;
obex_headerdata_t hd;
int size;
int rc;
state = OBEX_GetUserData(hdl);
if (event == OBEX_EV_PROGRESS) {
hd.bq4 = state->connid;
size = 4;
rc = OBEX_ObjectAddHeader(hdl, obj, OBEX_HDR_CONNECTION,
hd, size, 0);
if (rc < 0) {
printf("oah fail %d\n", rc);
}
return;
}
if (obex_rsp != OBEX_RSP_SUCCESS && obex_rsp != OBEX_RSP_CONTINUE) {
printf("FAIL %x %x\n", obex_rsp, event);
assert(0);
state->req_done++;
return;
}
switch (event) {
case OBEX_EV_REQDONE:
obex_requestdone(state, hdl, obj, obex_cmd, obex_rsp);
break;
default:
printf("Funny event\n");
}
}
int obex_get(obex_t *handle, const char *type, const char *name)
{
obex_context_t *context = OBEX_GetUserData(handle);
obex_object_t *object;
obex_headerdata_t hd;
int err, cmd;
g_return_val_if_fail(context != NULL, -1);
if (context->state != OBEX_OPEN && context->state != OBEX_CONNECT
&& context->state != OBEX_CONNECTED)
return -ENOTCONN;
cmd = OBEX_ObjectGetCommand(handle, NULL);
if (cmd == OBEX_CMD_GET || cmd == OBEX_CMD_PUT)
return -EBUSY;
/* Initialize transfer variables */
context->data_start = 0;
context->data_length = 0;
context->counter = 0;
context->target_size = -1;
context->modtime = -1;
context->close = 0;
object = OBEX_ObjectNew(handle, OBEX_CMD_GET);
if (!object)
return -ENOMEM;
if (context->cid != CID_INVALID) {
hd.bq4 = context->cid;
OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_CONNECTION, hd, 4, OBEX_FL_FIT_ONE_PACKET);
}
if (type) {
int len = strlen(type) + 1;
hd.bs = (uint8_t *) type;
err = OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_TYPE, hd, len, OBEX_FL_FIT_ONE_PACKET);
if (err < 0) {
OBEX_ObjectDelete(handle, object);
return err;
}
}
if (name) {
int len, ulen = (strlen(name) + 1) * 2;
uint8_t *unicode = malloc(ulen);
if (!unicode) {
OBEX_ObjectDelete(handle, object);
return -ENOMEM;
}
len = OBEX_CharToUnicode(unicode, (uint8_t *) name, ulen);
hd.bs = unicode;
err = OBEX_ObjectAddHeader(handle, object,
OBEX_HDR_NAME, hd, len, OBEX_FL_FIT_ONE_PACKET);
if (err < 0) {
OBEX_ObjectDelete(handle, object);
free(unicode);
return err;
}
free(unicode);
}
OBEX_ObjectReadStream(handle, object, NULL);
err = obex_send_or_queue(handle, object);
if (err < 0)
OBEX_ObjectDelete(handle, object);
return err;
}
obex_object_t *build_object_from_file(obex_t *handle, const char *filename, uint32_t creator_id)
{
obex_headerdata_t hdd;
uint8_t unicode_buf[200];
int namebuf_len;
obex_object_t *object;
//uint32_t creator_id;
int file_size;
char *name = NULL;
uint8_t *buf;
buf = easy_readfile(filename, &file_size);
if(buf == NULL)
return NULL;
/* Set Memopad as the default creator ID */
if(creator_id == 0)
creator_id = MEMO_PAD;
/* Find the . in the filename */
name = strchr(filename, '.');
if (name) {
name++;
if (strcmp(name, "vcf") == 0) {
printf( "This is a Address Book file\n");
creator_id = ADDRESS_BOOK;
} else if (strcmp(name, "vcs") == 0) {
printf( "This is a Date Book file\n");
creator_id = DATE_BOOK;
} else if (strcmp(name, "txt") == 0) {
printf("This is a Memo pad file\n");
creator_id = MEMO_PAD;
} else if (strcmp(name, "prc") == 0) {
printf("This is a Pilot resource file\n");
creator_id = PILOT_RESOURCE;
}
}
/* Build object */
object = OBEX_ObjectNew(handle, OBEX_CMD_PUT);
namebuf_len = OBEX_CharToUnicode(unicode_buf, (uint8_t *) filename, sizeof(unicode_buf));
hdd.bs = unicode_buf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_NAME,
hdd, namebuf_len, 0);
hdd.bq4 = file_size;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_LENGTH,
hdd, sizeof(uint32_t), 0);
#if 0
/* Optional header for win95 irxfer, allows date to be set on file */
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_TIME2,
(obex_headerdata_t) (uint32_t) stats.st_mtime,
sizeof(uint32_t), 0);
#endif
if (obex_protocol_type != 1) {
/* Optional header for Palm Pilot */
/* win95 irxfer does not seem to like this one */
hdd.bq4 = creator_id;
OBEX_ObjectAddHeader(handle, object, HEADER_CREATOR_ID,
hdd, sizeof(uint32_t), 0);
}
hdd.bs = buf;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_BODY,
hdd, file_size, 0);
free(buf);
return object;
}
int obex_setpath(obex_t *handle, const char *path, int create)
{
obex_context_t *context = OBEX_GetUserData(handle);
obex_object_t *object;
obex_headerdata_t hd;
obex_setpath_hdr_t sphdr;
int ret;
g_return_val_if_fail(context != NULL, -1);
if (context->state != OBEX_CONNECTED)
return -ENOTCONN;
object = OBEX_ObjectNew(handle, OBEX_CMD_SETPATH);
if (!object)
return -ENOMEM;
if (context->cid != CID_INVALID) {
hd.bq4 = context->cid;
OBEX_ObjectAddHeader(handle, object, OBEX_HDR_CONNECTION, hd, 4, 0);
}
memset(&sphdr, 0, sizeof(obex_setpath_hdr_t));
if (strcmp(path, "..") == 0) {
/* Can't create parent dir */
if (create)
return -EINVAL;
sphdr.flags = 0x03;
} else {
int len, ulen = (strlen(path) + 1) * 2;
uint8_t *unicode = malloc(ulen);
if (!create)
sphdr.flags = 0x02;
if (!unicode) {
OBEX_ObjectDelete(handle, object);
return -ENOMEM;
}
len = OBEX_CharToUnicode(unicode, (uint8_t *) path, ulen);
hd.bs = unicode;
ret = OBEX_ObjectAddHeader(handle, object, OBEX_HDR_NAME, hd, len, 0);
if (ret < 0) {
OBEX_ObjectDelete(handle, object);
free(unicode);
return ret;
}
free(unicode);
}
OBEX_ObjectSetNonHdrData(object, (uint8_t *) &sphdr, 2);
ret = obex_send_or_queue(handle, object);
if (ret < 0)
OBEX_ObjectDelete(handle, object);
return ret;
}
obex_t *smartpen_connect(short vendor, short product)
{
obex_t *handle;
obex_object_t *obj;
int rc, num, i;
struct obex_state *state;
obex_interface_t *obex_intf;
obex_headerdata_t hd;
int size, count;
char *buf;
again:
handle = OBEX_Init(OBEX_TRANS_USB, obex_event, 0);
if (!handle)
goto out;
num = OBEX_EnumerateInterfaces(handle);
for (i=0; i<num; i++) {
obex_intf = OBEX_GetInterfaceByIndex(handle, i);
if (!strcmp(obex_intf->usb.manufacturer, "Livescribe"))
break;
}
if (i == num) {
printf("No such device\n");
handle = NULL;
goto out;
}
state = malloc(sizeof(struct obex_state));
if (!state) {
handle = NULL;
goto out;
}
memset(state, 0, sizeof(struct obex_state));
if (!swizzle_usb(vendor, product)) {
handle = NULL;
goto out;
}
rc = OBEX_InterfaceConnect(handle, obex_intf);
if (rc < 0) {
printf("Connect failed %d\n", rc);
handle = NULL;
goto out;
}
OBEX_SetUserData(handle, state);
OBEX_SetTransportMTU(handle, 0x400, 0x400);
obj = OBEX_ObjectNew(handle, OBEX_CMD_CONNECT);
hd.bs = (unsigned char *)"LivescribeService";
size = strlen((char*)hd.bs)+1;
OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_TARGET, hd, size, 0);
rc = OBEX_Request(handle, obj);
count = state->req_done;
while (rc == 0 && state->req_done <= count) {
OBEX_HandleInput(handle, 100);
}
if (rc < 0 || !state->got_connid) {
printf("Retry connection...\n");
OBEX_Cleanup(handle);
goto again;
}
buf = get_named_object(handle, "ppdata?key=pp0000", &rc);
if (!buf) {
printf("Retry connection...\n");
OBEX_Cleanup(handle);
pen_reset(vendor, product);
goto again;
}
out:
return handle;
}
/*!
\internal
Takes all the headers contained in \a header and adds them as headers into
\a obj. If \a fitOnePacket is \c true, the OBEX_FL_FIT_ONE_PACKET flag
is used.
Returns whether the headers were written successfully.
*/
bool QObexHeaderPrivate::writeOpenObexHeaders(obex_t* handle, obex_object_t *obj, bool fitOnePacket, const QObexHeader &header)
{
if (!handle || !obj)
return false;
int flags = ( fitOnePacket ? OBEX_FL_FIT_ONE_PACKET : 0 );
obex_headerdata_t hv;
// Handle Target & Connection Id headers separately:
// Target must be the first header in operation, and Connection Id
// must be 1st header in a request (spec 2.2.7 & 2.2.11).
// This doesn't conflict cos they shouldn't both be in the same request
// (and for responses it doesn't say)
if (header.contains(QObexHeader::ConnectionId)) {
hv.bq4 = header.connectionId();
if (OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_CONNECTION, hv, 4,
flags) < 0) {
return false;
}
}
if (header.contains(QObexHeader::Target)) {
QByteArray bytes = header.target();
hv.bs = reinterpret_cast<const uchar *>(bytes.constData());
if (OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_TARGET, hv, bytes.size(),
flags) < 0) {
return false;
}
}
// now go through all the other headers
QList<int> headerIds = header.headerIds();
for (int i=0; i<headerIds.size(); i++) {
int headerId = headerIds[i];
// skip the previously handled headers
if (headerId == QObexHeader::ConnectionId ||
headerId == QObexHeader::Target) {
continue;
}
switch (headerId & QObexHeaderPrivate::HeaderEncodingMask) {
case QObexHeaderPrivate::HeaderUnicodeEncoding:
{
QByteArray bytes;
QObexHeaderPrivate::unicodeBytesFromString(bytes,
header.value(headerId).toString());
hv.bs = reinterpret_cast<const uchar *>(bytes.constData());
if (OBEX_ObjectAddHeader(handle, obj, headerId, hv,
bytes.size(), flags) < 0) {
return false;
}
break;
}
case QObexHeaderPrivate::HeaderByteSequenceEncoding:
{
if (headerId == QObexHeader::Type) {
// Handle Type header separately because it must be null terminated
// ascii. Use +1 when adding header to add a null terminator byte.
QByteArray bytes = header.type().toAscii();
hv.bs = reinterpret_cast<const uint8_t*>(bytes.constData());
if (OBEX_ObjectAddHeader(handle, obj, OBEX_HDR_TYPE, hv,
bytes.size() + 1, flags) < 0) {
return false;
}
// Add PalmOS-style application id header
if (!bytes.isEmpty() && header.type().compare("text/x-vCalendar",
Qt::CaseInsensitive) == 0) {
hv.bq4 = 0x64617465;
if (OBEX_ObjectAddHeader(handle, obj, 0xcf, hv, 4, flags) < 0) {
return false;
}
}
} else {
QByteArray bytes = header.value(headerId).toByteArray();
hv.bs = reinterpret_cast<const uchar *>(bytes.constData());
if (OBEX_ObjectAddHeader(handle, obj, headerId, hv, bytes.size(),
flags) < 0) {
return false;
}
}
break;
}
case QObexHeaderPrivate::HeaderByteEncoding:
{
QVariant v = header.value(headerId);
if (v.canConvert<quint8>()) {
hv.bq1 = v.value<quint8>();
if (OBEX_ObjectAddHeader(handle, obj, headerId, hv, 1,
flags) < 0) {
return false;
}
} else {
// this shouldn't happen since setValue() does a check
return false;
}
break;
}
case QObexHeaderPrivate::HeaderIntEncoding:
{
QVariant v = header.value(headerId);
if (v.canConvert<quint32>()) {
hv.bq4 = v.value<quint32>();
if (OBEX_ObjectAddHeader(handle, obj, headerId, hv, 4,
flags) < 0) {
return false;
}
} else {
// this shouldn't happen since setValue() does a check
return false;
}
break;
}
default:
return false;
}
}
return true;
}
/**
Connect this ObexFTP client using a given source address by sending an OBEX CONNECT request.
\param cli an obexftp_client_t created by obexftp_open().
\param src optional local source interface address (transport specific)
\param device the device address to connect to (transport specific)
\param port the port/channel for the device address
\param uuid UUID string for CONNECT (no default)
\param uuid_len length of the UUID string (excluding terminating zero)
\return the result of the CONNECT request, -1 on error
\note Always use a UUID (except for OBEX PUSH)
*/
int obexftp_connect_src(obexftp_client_t *cli, const char *src, const char *device, int port, const uint8_t uuid[], uint32_t uuid_len)
{
struct sockaddr_in peer;
#ifdef HAVE_BLUETOOTH
char *devicedup, *devicep;
bdaddr_t bdaddr, src_addr;
#endif
#ifdef HAVE_USB
int obex_intf_cnt;
obex_interface_t *obex_intf;
#endif
obex_object_t *object;
obex_headerdata_t hv;
int ret = -1; /* no connection yet */
DEBUG(3, "%s()\n", __func__);
return_val_if_fail(cli != NULL, -EINVAL);
cli->infocb(OBEXFTP_EV_CONNECTING, "", 0, cli->infocb_data);
switch (cli->transport) {
case OBEX_TRANS_IRDA:
ret = IrOBEX_TransportConnect(cli->obexhandle, "OBEX");
DEBUG(3, "%s() IR %d\n", __func__, ret);
break;
case OBEX_TRANS_INET:
if (!device) {
ret = -EINVAL;
break;
}
#ifdef _WIN32
peer.sin_addr.s_addr = inet_addr(device);
ret = (peer.sin_addr.s_addr == INADDR_NONE) ? 0 : 1;
#else
ret = inet_aton(device, &peer.sin_addr);
#endif
if (ret) {
peer.sin_family = AF_INET;
peer.sin_port = htons(port); /* overridden with OBEX_PORT 650 anyhow */
ret = InOBEX_TransportConnect(cli->obexhandle, (struct sockaddr *) &peer,
sizeof(struct sockaddr_in));
DEBUG(3, "%s() TCP %d\n", __func__, ret);
} else
ret = -EINVAL; /* is there a better errno? */
break;
case OBEX_TRANS_CUSTOM:
/* don't change the custom transport once it is in place */
if (cli->ctrans == NULL) {
cli->ctrans = cobex_ctrans (device);
if(OBEX_RegisterCTransport(cli->obexhandle, cli->ctrans) < 0) {
DEBUG(1, "Custom transport callback-registration failed\n");
}
}
ret = OBEX_TransportConnect(cli->obexhandle, NULL, 0);
DEBUG(3, "%s() TC %d\n", __func__, ret);
break;
#ifdef HAVE_BLUETOOTH
case OBEX_TRANS_BLUETOOTH:
if (!src) {
bacpy(&src_addr, BDADDR_ANY);
}
#ifdef HAVE_SDPLIB
else if (!strncmp(src, "hci", 3)) {
hci_devba(atoi(src + 3), &src_addr);
}
else if (atoi(src) != 0) {
hci_devba(atoi(src), &src_addr);
}
#endif
else {
str2ba(src, &src_addr);
}
if (!device) {
ret = -EINVAL;
break;
}
if (port < 1) {
port = obexftp_browse_bt(device, OBEX_FTP_SERVICE);
}
/* transform some chars to colons */
devicedup = devicep = strdup(device);
for (; *devicep; devicep++) {
if (*devicep == '-') *devicep = ':';
if (*devicep == '_') *devicep = ':';
if (*devicep == '/') *devicep = ':';
}
(void) str2ba(devicedup, &bdaddr);
free(devicedup);
ret = BtOBEX_TransportConnect(cli->obexhandle, &src_addr, &bdaddr, (uint8_t)port);
DEBUG(3, "%s() BT %d\n", __func__, ret);
break;
#endif /* HAVE_BLUETOOTH */
#ifdef HAVE_USB
case OBEX_TRANS_USB:
obex_intf_cnt = OBEX_FindInterfaces(cli->obexhandle, &obex_intf);
DEBUG(3, "%s() \n", __func__);
if (obex_intf_cnt <= 0) {
DEBUG(1, "%s() there are no valid USB interfaces\n", __func__);
ret = -EINVAL; /* is there a better errno? */
}
else if (port >= obex_intf_cnt) {
DEBUG(1, "%s() %d is an invalid USB interface number\n", __func__, port);
ret = -EINVAL; /* is there a better errno? */
} else
ret = OBEX_InterfaceConnect(cli->obexhandle, &obex_intf[port]);
DEBUG(3, "%s() USB %d\n", __func__, ret);
break;
#endif /* HAVE_USB */
default:
ret = -ESOCKTNOSUPPORT;
break;
}
if (ret < 0) {
/* could be -EBUSY or -ESOCKTNOSUPPORT */
cli->infocb(OBEXFTP_EV_ERR, "connect", 0, cli->infocb_data);
return ret;
}
#ifdef COMPAT_S45
// try S45 UUID first.
object = OBEX_ObjectNew(cli->obexhandle, OBEX_CMD_CONNECT);
hv.bs = UUID_S45;
if(OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_TARGET,
hv, sizeof(UUID_S45), OBEX_FL_FIT_ONE_PACKET) < 0) {
DEBUG(1, "Error adding header\n");
OBEX_ObjectDelete(cli->obexhandle, object);
return -1;
}
cli->connection_id = 0xffffffff;
ret = cli_sync_request(cli, object);
if(ret < 0) {
cli->infocb(OBEXFTP_EV_ERR, "S45 UUID", 0, cli->infocb_data);
#endif
object = OBEX_ObjectNew(cli->obexhandle, OBEX_CMD_CONNECT);
if (uuid) {
hv.bs = uuid;
if(OBEX_ObjectAddHeader(cli->obexhandle, object, OBEX_HDR_TARGET,
hv, uuid_len, OBEX_FL_FIT_ONE_PACKET) < 0) {
DEBUG(1, "Error adding header\n");
OBEX_ObjectDelete(cli->obexhandle, object);
return -1;
}
}
cli->connection_id = 0xffffffff;
ret = cli_sync_request(cli, object);
if (!OBEXFTP_USE_CONN_HEADER(cli->quirks))
cli->connection_id = 0xffffffff;
#ifdef COMPAT_S45
}
#endif
if(ret < 0)
cli->infocb(OBEXFTP_EV_ERR, "send UUID", 0, cli->infocb_data);
else
cli->infocb(OBEXFTP_EV_OK, "", 0, cli->infocb_data);
return ret;
}