ircp_server.c

来自「sparc硬件平台上的红外协议」· C语言 代码 · 共 357 行

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "obex.h"

#include "ircp.h"
#include "ircp_io.h"
#include "ircp_server.h"
#include "obex_main.h"

#include "types.h"
#ifndef EMMI_SPARC
#ifdef TEST_IRDA
#include <sched.h>
#include <pthread.h>
#endif
#endif
//
// Incoming event from OpenOBEX
//
void srv_obex_event(obex_t *handle, obex_object_t *object, int mode, int event, int obex_cmd, int obex_rsp)
{
	ircp_server_t *srv;
	int ret;
	
	srv = OBEX_GetUserData(handle);
	// DEBUG(4, "\n");
	
	switch (event)	{
	case OBEX_EV_STREAMAVAIL:
		DEBUG(5, "Time to read some data from stream\n");
		ret = ircp_srv_receive(srv, object, FALSE);
		break;
	case OBEX_EV_PROGRESS:
		break;
	case OBEX_EV_REQ:
		DEBUG(4, "Incoming request %02x, %d\n", obex_cmd, OBEX_CMD_SETPATH);
		
		switch(obex_cmd) {
		case OBEX_CMD_CONNECT:
			srv->infocb(IRCP_EV_CONNECTIND, "");	
			ret = 1;
			break;
		case OBEX_CMD_DISCONNECT:
			srv->infocb(IRCP_EV_DISCONNECTIND, "");	
			ret = 1;
			break;
			
		case OBEX_CMD_PUT:
			ret = ircp_srv_receive(srv, object, TRUE);
			break;
			
		default:
			ret = 1;
			break;
		}
		
		if(ret < 0) {
			srv->finished = TRUE;
			srv->success = FALSE;
		}
		
		break;
		
		case OBEX_EV_REQHINT:
			/* An incoming request is about to come. Accept it! */
			switch(obex_cmd) {
			case OBEX_CMD_PUT:
				DEBUG(4, "Going to turn streaming on!\n");
				/* Set response to ok! */
				OBEX_ObjectSetRsp(object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
				/* Turn streaming on */
				OBEX_ObjectReadStream(handle, object, NULL);
				break;
				
			case OBEX_CMD_SETPATH:
			case OBEX_CMD_CONNECT:
			case OBEX_CMD_DISCONNECT:
				/* Set response to ok! */
				OBEX_ObjectSetRsp(object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
				break;
				
			default:
				DEBUG(0, "Skipping unsupported command:%02x\n", obex_cmd);
				OBEX_ObjectSetRsp(object, OBEX_RSP_NOT_IMPLEMENTED, OBEX_RSP_NOT_IMPLEMENTED);
				break;
				
			}
			break;
			
			case OBEX_EV_REQDONE:
				if(obex_cmd == OBEX_CMD_DISCONNECT) {
					srv->finished = TRUE;
					srv->success = TRUE;
				}
				break;
				
			case OBEX_EV_LINKERR:
				DEBUG(0, "Link error\n");
				srv->finished = TRUE;
				srv->success = FALSE;
				break;
			default:
				break;
	}
}

//
//
//
#ifndef EMMI_SPARC
#ifdef TEST_IRDA
extern int min_priority;
void set_irda_pthread_param(int priority)
{
    struct sched_param irda_param;
    irda_param.sched_priority = priority + min_priority;
    pthread_setschedparam(pthread_self(),SCHED_FIFO,&irda_param);
}
#endif
#endif

extern int rec_over_flag;
int ircp_srv_recv(ircp_server_t *srv)
{
	int ret;
#ifndef EMMI_SPARC
#ifdef TEST_IRDA
	set_irda_pthread_param(4);
#endif
#endif
	while(srv->finished == FALSE) {
		ret = OBEX_HandleInput(srv->obexhandle, 1);
		if (ret < 0)
			return -1;
	}
	//notify_rec();
	if(srv->success)
		return 1;
	else
		return -1;
}


//
// Open a file for receivning
//
static int new_file(ircp_server_t *srv, obex_object_t *object)
{
	obex_headerdata_t hv;
	uint8_t hi;
	uint32_t hlen;
	char *name = NULL;
	int ret = -1;
	
	/* First iterate through recieved header to find name */
	while (OBEX_ObjectGetNextHeader(srv->obexhandle, object, &hi, &hv, &hlen))	{
		switch(hi)	{
		case OBEX_HDR_NAME:
			if( (name = malloc(hlen / 2)))	{
				OBEX_UnicodeToChar((uint8_t *) name, hv.bs, hlen);
			}
			else
			{
				DEBUG(4,"can not alloc memory\n");
			}
			break;
		default:
			DEBUG(4, "Skipped header %02x\n", hi);
		}
	}
	if(name == NULL)	{
		DEBUG(0, "Got a PUT without a name. Refusing\n");
		/* Send back error */
		OBEX_ObjectSetRsp(object, OBEX_RSP_BAD_REQUEST, OBEX_RSP_BAD_REQUEST);
		srv->infocb(IRCP_EV_ERR, "");
		goto out;
	}
	
	srv->infocb(IRCP_EV_RECEIVING, name);	
	srv->fd = ircp_open_safe("", name);
	
	ret = srv->fd;
	
out:	free(name);
		return ret;
}
int ircp_srv_receive(ircp_server_t *srv, obex_object_t *object, int finished)
{
	const uint8_t *body = NULL;
	int body_len = 0;
	static int iflag = 0;
    static int ioffset = 0;
static    D_UINT8 *mem = NULL;

	if(srv->fd < 0 && finished == FALSE) {
		/* Not receiving a file */
		if(new_file(srv, object) < 0)
			return 1;
	}
	
	if(finished == TRUE) {
		/* Recieve done! */
		DEBUG(4, "Done!...\n");
		return 1;		
	}
	//这里用的是romfs，fd刚还为0
	else if (srv->fd == 0) {
		/* fd is valid. We are currently receiving a file */
		body_len = OBEX_ObjectReadStream(srv->obexhandle, object, &body);
		DEBUG(5, "Got %d bytes of stream-data\n", body_len);
		
		if(body_len < 0) {
			/* Error */
		}
		else if(body_len == 0) {
			/* EOS */
			if (mem != NULL)
			{
				
				srv_gui_gif(10,10,mem,0);
                            free (mem);
                            mem = NULL;
			}
			
			srv->fd = -1;
			srv->infocb(IRCP_EV_OK, "");
		}
		else {
			if(srv->fd == 0)
			{

				if (iflag == 0)
				{
					
					mem =  (D_UINT8*)malloc(6000);
					memset(mem,0,6000);
					iflag =  1;
					
				}
				
				memcpy(mem+ioffset,body,body_len);
				ioffset += body_len;
			}
		}
		return 1;
	}
	return -1;
}	


//
// Extract interesting things from object and save to disk.
//
int ircp_srv_receive1(ircp_server_t *srv, obex_object_t *object, int finished)
{
	const uint8_t *body = NULL;
	int body_len = 0;
	
	if(srv->fd < 0 && finished == FALSE) {
		/* Not receiving a file */
		if(new_file(srv, object) < 0)
			return 1;
	}
	
	if(finished == TRUE) {
		/* Recieve done! */
		DEBUG(4, "Done!...\n");
		return 1;		
	}
	else if (srv->fd > 0) {
		/* fd is valid. We are currently receiving a file */
		body_len = OBEX_ObjectReadStream(srv->obexhandle, object, &body);
		DEBUG(5, "Got %d bytes of stream-data\n", body_len);
		
		if(body_len < 0) {
			/* Error */
		}
		else if(body_len == 0) {
			/* EOS */
			close(srv->fd);
			srv->fd = -1;
			srv->infocb(IRCP_EV_OK, "");
		}
		else {
			if(srv->fd > 0)
			{
				write(srv->fd, body, body_len);
			}
		}
		return 1;
	}
	return -1;
}	

//
// Create an ircp server
//
ircp_server_t *ircp_srv_open(ircp_info_cb_t infocb)
{
	ircp_server_t *srv;
	
	DEBUG(4, "\n");
	srv = malloc(sizeof(ircp_server_t));
	if(srv == NULL)
	{
		DEBUG(4,"can not alloc memory\n");
		return NULL;
	}
	memset(srv,0,sizeof(ircp_server_t));
	
	srv->fd = -1;
	srv->infocb = infocb;
	
	srv->obexhandle = OBEX_Init(OBEX_TRANS_IRDA, srv_obex_event, 0);
	
	DEBUG(4, "%x\n",srv->obexhandle);
	if(srv->obexhandle == NULL) {
		free(srv);
		return NULL;
	}
	OBEX_SetUserData(srv->obexhandle, srv);
	return srv;
}

//
// Close an ircp server
//
void ircp_srv_close(ircp_server_t *srv)
{
	DEBUG(4, "\n");
	ircp_return_if_fail(srv != NULL);
	
	OBEX_Cleanup(srv->obexhandle);
	free(srv);
}

//
// Wait for incoming files.
//
int ircp_srv_accept(ircp_server_t *srv, char *inbox)
{
	
	srv->dirdepth = 0;
	
	if(IrOBEX_ServerRegister(srv->obexhandle, "OBEX") < 0)
		return -1;
	srv->infocb(IRCP_EV_LISTENING, "");
	srv->inbox = inbox;
	
	
	return 0;
}