smshandle.c

在GPRS或者CDMA modem上实现发送/接收短信的C代码；支持Siemens

#include "typedef.h"
#ifdef _LINUX_
#include <unistd.h>
#include <pthread.h>
#endif

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

#include "sms.h"
#include "smshandle.h"
#include "errordef.h"


int giSmsNodeWrite = 0;
int giSmsNodeCnt   = 0;//MAX_SMS_NODE;

SMS_NODE* smsnode_head = NULL;
SMS_NODE* smsnode_tail = NULL;
SMS_NODE* smsnode_cur  = NULL;


/* for synchronous */
#ifdef _LINUX_
pthread_mutex_t smsnod_mutex = PTHREAD_MUTEX_INITIALIZER;
#else
//windows mutex declaration
#endif

void P(void)
{
#ifdef _LINUX_
	pthread_mutex_lock(&smsnod_mutex);
#endif
}

void V(void)
{
#ifdef _LINUX_
	pthread_mutex_unlock(&smsnod_mutex);
#endif
}

/* 
* SMS handle Operations 
* encapsulate SMS NODE operations
*/
int allocsmshandle(SmsHandle* hSmsHandle);
int addsmshandle(SmsHandle* hSmsHandle);
int delsmshandle(SmsHandle* hSmsHandle);
int searchsmshandle(SmsHandle* hSmsHandle);
int findnode(const char* ttyname);

/* SMS node Operations */
int initsmsnodebuf(void);  //unnecessary
SMS_NODE* allocsmsnode(void); 
int addsmsnode(SMS_NODE* pSmsNode);
int delsmsnode(SMS_NODE* pSmsNode);
int freesmsnode(SMS_NODE* pSmsNode);
int searchsmsnode(SMS_NODE* pSmsNode);

/* Functions Implementation */
int allocsmshandle(SmsHandle* hSmsHandle)
{
	int ret;
	SMS_NODE* pSmsNode = NULL;

	pSmsNode = allocsmsnode();
	if (pSmsNode == NULL)
	{
		WMMP_TRACE(debugType, "\r\nError: allocate a SMS NODE!");
        ret = -SMS_ERR_ALLOC_SMSNODE;
		goto allocsmshandle_fail;
	}
    //add smsnode
	ret = addsmsnode(pSmsNode);
	if (ret < 0)
	{
		WMMP_TRACE(debugType, "\r\nError: add a SMS NODE!");
		freesmsnode(pSmsNode);
		goto allocsmshandle_fail;
	}

	*hSmsHandle = pSmsNode;
	WMMP_TRACE(debugType, "\r\n*hSmsHandle = %#x; pSmsNode = %#x", *hSmsHandle, pSmsNode);

	return 0;

allocsmshandle_fail:
	return ret;
}

int addsmshandle(SmsHandle* hSmsHandle)
{
	int ret;
	SMS_NODE* pSmsNode;

	pSmsNode = *hSmsHandle;
	ret = addsmsnode(pSmsNode);
	if (ret < 0)
	{
		WMMP_TRACE(debugType, "\r\nError: add a SMS NODE!");
		goto addsmshandle_fail;
	}

	WMMP_TRACE(debugType, "\r\nSucc to add a SMS NODE!");
	return 0;

addsmshandle_fail:
	return ret;
}

int delsmshandle(SmsHandle* hSmsHandle)
{
    int ret;
	SMS_NODE* pSmsNode;

	pSmsNode = *hSmsHandle;
	
	ret = delsmsnode(pSmsNode);
	if (ret < 0)
	{
		WMMP_TRACE(debugType, "\r\nError: delete SMS NODE!");
		goto delsmshandle_fail;
	}
    freesmsnode(pSmsNode);
	WMMP_TRACE(debugType, "\r\nSucc to delete a SMS NODE!");
	return 0;

delsmshandle_fail:
	return ret;
}

int searchsmshandle(SmsHandle* hSmsHandle)
{
	int ret;
	SMS_NODE* pSmsNode;

	pSmsNode = *hSmsHandle;
	ret = searchsmsnode(pSmsNode);
	if (ret < 0)
	{
		WMMP_TRACE(debugType, "\r\nError: search SMS NODE!");
		goto searchsmsnode_fail;
	}

    WMMP_TRACE(debugType, "\r\nSucc to search given SMS NODE!");
	return 0;

searchsmsnode_fail:
	return ret;
}

int findnode(const char* ttyname)
{
	int ret;
	SMS_NODE* pSmsNode;
	
	P();

	ret = -SMS_ERR_TTY_UNFOUND;
	pSmsNode = smsnode_head;
	while (pSmsNode != NULL)
	{
		if (!memcmp(ttyname, pSmsNode->ttyname, strlen(ttyname)))
		{
			ret = -SMS_ERR_DEV_USED;
			break;
		}
		pSmsNode = pSmsNode->next_node;
	}
    V();
	
	return ret;
}

/*
* From here, implementing SMS NODE operations.
* These functions are encapsulated in SMS HANDLE operations.  
*/
SMS_NODE* allocsmsnode(void)
{
    SMS_NODE *pSmsNode;
	
	P();
	WMMP_TRACE(debugType, "\r\nallocsmsnode: gCnt=%d.", giSmsNodeCnt++);

	//dynamic allocate a sms node buffer
	pSmsNode = (SMS_NODE*)malloc(sizeof(SMS_NODE));
	if (pSmsNode == NULL)
	{
		WMMP_TRACE(debugType, "\r\nallocsmsnode: ret null1.");
        V();
		return NULL;
	}

	memset(pSmsNode, 0, sizeof(SMS_NODE));

	WMMP_TRACE(debugType, "\r\nallocsmsnode: ret %x.", pSmsNode);

    V();

	return pSmsNode;

}

int addsmsnode(SMS_NODE* pSmsNode)
{
	P();

	if (pSmsNode == NULL)
	{
    	WMMP_TRACE(debugType, "\r\nError: pSmsNode is NULL!");
		V();
		return -SMS_ERR_PARAMS;
	}

	if (smsnode_head == NULL)
	{
		smsnode_head = pSmsNode;
		smsnode_tail = pSmsNode;
	}
	else
	{
        if (smsnode_tail == NULL)
        {
			smsnode_tail = pSmsNode;
        }
		else
		{
			smsnode_tail->next_node = pSmsNode;
			smsnode_tail = pSmsNode;
		}
	}
	
	pSmsNode->next_node = NULL;
    V();

	return 0;
}

int delsmsnode(SMS_NODE* pSmsNode)
{
	SMS_NODE* pCurSmsNode = NULL;
	SMS_NODE* pPreSmsNode = NULL;
	int ret;

    P();

	if (pSmsNode == NULL)
    {
		WMMP_TRACE(debugType, "\r\nError: pSmsNode is NULL!");
		ret = -SMS_ERR_PARAMS;
		goto delsmsnode_fail;
    }
    
	if(smsnode_head == NULL)
	{
		WMMP_TRACE(debugType, "\r\nError: SMS NODE is empty!");
		ret = -SMS_ERR_NODE_EMPTY;
		goto delsmsnode_fail;
	}
	
	if (smsnode_head == smsnode_tail)
	{//only one SMS NODE
		if (pSmsNode != smsnode_head)
		{
			WMMP_TRACE(debugType, "\r\nError: Unknown sms node!");
			ret = -SMS_ERR_UNKNOWN_SMSNODE;
			goto delsmsnode_fail;
		}
		smsnode_head = smsnode_tail = NULL;
		ret = 0;
		goto delsmsnode_succ;
	}
	
	pCurSmsNode = smsnode_head;
	pPreSmsNode = smsnode_head;
	while (pCurSmsNode != NULL)
	{
		if (pCurSmsNode == pSmsNode)
		{//we finded the wanted SMS node
			if (pCurSmsNode == smsnode_head)
			{//the wanted node is the first one
                smsnode_head = pCurSmsNode->next_node;
			}
			else if (pCurSmsNode == smsnode_tail)
			{//the wanted node is the last one
                smsnode_tail = pPreSmsNode;
				pPreSmsNode->next_node = NULL;
			}
			else
			{
				pPreSmsNode->next_node = pCurSmsNode->next_node;
			}

			pCurSmsNode->next_node = NULL;
            
			WMMP_TRACE(debugType, "\r\nHave found the wanted sms node!");
			break;            
		}
        //continue to find in smsnode list
		pPreSmsNode = pCurSmsNode;
		pCurSmsNode = pCurSmsNode->next_node;
	}
    
	if (pCurSmsNode == NULL)
	{
		WMMP_TRACE(debugType, "\r\nError: Can not find the wanted SMS NODE!");
		ret = -SMS_ERR_UNKNOWN_SMSNODE;
		goto delsmsnode_fail;
	}
	
delsmsnode_succ:
	V();
	return 0;

delsmsnode_fail:
	V();
	return ret;
}

int freesmsnode(SMS_NODE* pSmsNode)
{
	P();
	free(pSmsNode);
	V();
	return 0;
}

int searchsmsnode(SMS_NODE* pSmsNode)
{
	SMS_NODE* pCurSmsNode;
	int found = 0; //not found
	
	P();

	pCurSmsNode = smsnode_head;

	while (pCurSmsNode != NULL)
	{
		if (pCurSmsNode == pSmsNode)
		{
            found = 1;
			break;
		}
		pCurSmsNode = pCurSmsNode->next_node;
	}

	if (found == 1)
	{
		V();
		return 0;
	}
	else
	{// not found
		V();
        return -SMS_ERR_UNKNOWN_SMSNODE;
	}

}