client.c

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    default:
	printf("Error %d returned from server\n", pkt.header.resp);
	return (CL_CLIENT_ERROR);
    }
}

int
ClRegister(unsigned char *name, int *flags)
{
    return (local_Register(name, CL_NORMAL_CLIENT, flags));
}

int
ClReconnect(unsigned char *name)
{
    g_socket = 0;
    return (local_Register(name, CL_NORMAL_CLIENT, 0));
}

int
ClClose(void)
{

    pkt_buff_t *head = pkt_queue;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);

    /* Free any queued packets */

    while (head) {
	pkt_buff_t *next = head->next;
	pkt_free(head);
	head = next;
    }

    close(g_socket);
    g_socket = 0;

#ifdef MALLOC_DEBUG
    printf("MALLOC_DEBUG:  The end result was %d\n", g_malloc);
#endif

    return (0);
}

int
ClFindApp(unsigned char *name)
{

    cl_pkt_findapp pkt;
    int ret;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!name)
	return (CL_CLIENT_INVALID);

    bzero(&pkt, sizeof(pkt));

    /* Construct the find app packet */
    strncpy(pkt.name, name, CL_MAX_NAME_LEN);

    ret = client_MakeRequest(g_socket, CL_PKT_FINDAPP,
			     (cl_packet *) & pkt, sizeof(pkt), 0);

    if (ret < 0)
	return (ret);

    switch (pkt.header.resp) {
    case CL_E_NOAPP:
	return (CL_CLIENT_NOTFOUND);

    case 0:
	return (pkt.ipc_id);

    default:
	printf("Error %d returned from server\n", pkt.header.resp);
	return (CL_CLIENT_ERROR);
    }
}

int
ClStartApp(unsigned char *name, unsigned char *args, int flags, int timeout)
{

    cl_pkt_start pkt;
    int ret;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!name)
	return (CL_CLIENT_INVALID);

    bzero(&pkt, sizeof(pkt));

    /* Construct the find app packet */
    strncpy(pkt.name, name, CL_MAX_NAME_LEN);

    if (args)
	strncpy(pkt.argstr, args, CL_MAX_ARG_LEN);

    pkt.timeout = timeout;
    pkt.start_flags = flags;

    /* Wait up to timeout seconds */
    ret = client_MakeRequest(g_socket, CL_PKT_STARTAPP,
			     (cl_packet *) & pkt, sizeof(pkt),
			     timeout * 1000000);

    if (ret < 0)
	return (ret);

    switch (pkt.header.resp) {
    case CL_E_NOAPP:
    case CL_E_APPERR:
	return (CL_CLIENT_NOTFOUND);

    case 0:
	return (pkt.ipc_id);

    default:
	printf("Error %d returned from server\n", pkt.header.resp);
	return (CL_CLIENT_ERROR);
    }

}

int
ClSpawnApp(unsigned char *name, unsigned char *args)
{

    cl_pkt_spawn pkt;
    int ret;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!name)
	return (CL_CLIENT_INVALID);

    bzero(&pkt, sizeof(pkt));

    /* Construct the find app packet */
    strncpy(pkt.name, name, CL_MAX_NAME_LEN);

    if (args)
	strncpy(pkt.argstr, args, CL_MAX_ARG_LEN);

    /* Wait up to timeout seconds */

    ret = client_MakeRequest(g_socket, CL_PKT_SPAWNAPP,
			     (cl_packet *) & pkt, sizeof(pkt), 0);

    if (ret < 0)
	return (ret);

    switch (pkt.header.resp) {
    case CL_E_SPAWNERR:
	return (CL_CLIENT_NOTFOUND);

    case 0:
	return (pkt.pid);

    default:
	printf("Error %d returned from server\n", pkt.header.resp);
	return (CL_CLIENT_ERROR);
    }
}

int
clGetAppInfo(cl_app_info * info)
{

    int ret;
    cl_pkt_appinfo pkt;

    pkt.flags = info->flags;

    switch (info->flags) {
    case CL_APP_INFO_NAME:
	strcpy(pkt.name, info->name);
	break;
    case CL_APP_INFO_PID:
	pkt.processid = info->processid;
	break;
    }

    /* Wait 500 ms for a response */
    ret = client_MakeRequest(g_socket, CL_PKT_APP_INFO,
			     (cl_packet *) & pkt, sizeof(pkt), 0);

    if (ret < 0)
	return (ret);

    if (pkt.header.resp == CL_E_NOSUCHAPP)
	return (CL_CLIENT_NOTFOUND);

    info->flags = pkt.flags;
    info->processid = pkt.processid;
    strcpy(info->name, pkt.name);

    return (0);
}

int
ClSendMessage(int id, void *message, int len)
{

    pkt_buff_t *buffer = 0;
    cl_packet *response = 0;
    cl_pkt_message *pkt = 0;
    int ret = 0;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!message)
	return (CL_CLIENT_INVALID);

    if (!len)
	return (0);

    /* Allocate enough room for the packet */
    /* Note:  This must be on the heap because it can be pretty big */

    if (MESSAGE_PKT_SIZE(len) > CL_MAX_PKT_SIZE) {
	ERROR("Message size [%d] is too big - Rejecting it\n", len);
	return (CL_CLIENT_INVALID);
    }

    pkt = CALLOC(MESSAGE_PKT_SIZE(len), 1);

    pkt->dest = id;
    pkt->msglen = len;

    memcpy(&pkt->message, message, len);

    pkt->header.type = CL_PKT_MESSAGE;
    pkt->header.len = MESSAGE_PKT_SIZE(len);

    /* Send the packet */

    ret =
	client_SendToServer(g_socket, (unsigned char *) pkt,
			    MESSAGE_PKT_SIZE(len));

    if (ret == -1) {
	FREE(pkt);
	return (CL_CLIENT_ERROR);
    }

    else if (ret == 1) {
	FREE(pkt);
	return (client_ServerDied());
    }

    ret = client_WaitForServer(g_socket, CL_PKT_MSG_RESPONSE, &buffer, 0);

    if (ret < 0 || buffer == 0) {
	pkt_free(buffer);
	FREE(pkt);
	return (CL_CLIENT_ERROR);
    }

    response = (cl_packet *) buffer->packet;

    switch (response->header.resp) {
    case CL_E_NODEST:
	ret = CL_CLIENT_NODEST;
	break;

    case 0:
	ret = 0;
	break;

    default:
	ret = CL_CLIENT_ERROR;
	break;
    }

    FREE(pkt);
    pkt_free(buffer);

    return (ret);
}

int
ClLookupName(int id, unsigned char *name, int *len)
{

    int ret;
    cl_pkt_findname pkt;

    bzero(&pkt, sizeof(pkt));

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!name || !len || !*len)
	return (CL_CLIENT_INVALID);

    /* Construct the find app packet */
    pkt.id = id;

    /* Wait 500 ms for a response */
    ret = client_MakeRequest(g_socket, CL_PKT_FINDNAME,
			     (cl_packet *) & pkt, sizeof(pkt), 0);

    if (ret < 0)
	return (ret);

    strncpy(name, pkt.name, *len);

    *len = strlen(pkt.name);
    return (0);
}

int
ClGetMessage(void *msg, int *len, unsigned short *src)
{

    pkt_buff_t *buffer = 0;
    cl_pkt_message *msgpkt;

    int wlen;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!msg || !len || !*len)
	return (CL_CLIENT_INVALID);

    /* It there is something in the queue, get it there first */
    if (client_DequeuePacket(&buffer) == 0) {
	int rlen = client_GetFromServer(g_socket, &buffer);

	if (rlen == 0) {
	  printf("CLCLIENT:  client_GetFromServer() returned 0\n");
	  return (CL_CLIENT_NODATA);
	}
	else if (rlen == -1)
	    return (CL_CLIENT_ERROR);
    }

    msgpkt = (cl_pkt_message *) buffer->packet;

    /* This shouldn't happen, but it occasionally does */

    if (msgpkt->header.type == CL_PKT_MSG_RESPONSE) {
      printf("CLCLIENT:  Invalid header type\n");
      return (CL_CLIENT_NODATA);
    }

    wlen = (msgpkt->msglen > *len ? *len : msgpkt->msglen);

    memcpy(msg, &msgpkt->message, wlen);
    *len = wlen;

    *src = msgpkt->src;

    pkt_free(buffer);

    return (msgpkt->dest == CL_MSG_BROADCAST_ID)
	? CL_CLIENT_BROADCAST : CL_CLIENT_SUCCESS;
}

int
ClGetNextMessage(void *msg, int *len)
{

    int msgsrc = 0;

    pkt_buff_t *buffer = 0;
    cl_pkt_message *pkt;
    int wlen;

    /* It there is something in the queue, get it there first */

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!msg || !len || !*len)
	return (CL_CLIENT_INVALID);

    if (!client_DequeuePacket(&buffer)) {
	int ret = client_WaitForServer(g_socket, CL_PKT_MESSAGE, &buffer, 0);

	if (ret == 1)
	    return (client_ServerDied());
	else if (ret == -1)
	    return (CL_CLIENT_ERROR);
    }

    pkt = (cl_pkt_message *) buffer->packet;

    wlen = (pkt->msglen > *len ? *len : pkt->msglen);
    memcpy(msg, &pkt->message, wlen);
    *len = wlen;
    msgsrc = pkt->src;

    pkt_free(buffer);
    return (msgsrc);
}

#ifdef HAVE_LOGGING

int
ClLogMessage(int level, unsigned char *message)
{

    cl_pkt_log pkt;
    int ret;

    if (!g_socket)
	return (CL_CLIENT_NOCONN);
    if (!message)
	return (CL_CLIENT_INVALID);

    bzero(&pkt, sizeof(pkt));

    pkt.level = level;
    strncpy(pkt.message, message, CL_MAX_LOG_LEN);

    pkt.header.type = CL_PKT_LOG;
    pkt.header.len = sizeof(pkt);

    ret = client_SendToServer(g_socket, (unsigned char *) &pkt, sizeof(pkt));

    return (ret);
}

int
ClRegisterLogger(char *name)
{
    return (local_Register(name, CL_LOG_CLIENT, 0));
}

#else /* HAVE_LOGGING */

int
ClLogMessage(int level, unsigned char *name)
{
    return (CL_E_NOTIMPLEMENT);
}

int
ClRegisterLogger(char *name)
{
    return (CL_E_NOTIMPLEMENT);
}

#endif /* HAVE_LOGGING */