pdu.c

在Linux中

/***********************************
构造PDU字符串
输入：短信，对方手机号码，以及短信中心号码
输出：PDU字符串，采用USC2编码

作者：蒙德鑫
时间：2008/12/10
************************************/

#include <string.h>
#include	<stdio.h>
#include <stdlib.h>
#include <iconv.h>
#include "PDU.h"



/*
* from_addr为短信中心号码，必须以“86”开头，且号码长度（不含“86”）必须是11位，如“8613800200500”
* to_addr保存为对短信中心号码处理后的结果，保证该缓冲区足够大（至少19个字节）
*/
static void msg_center_dealwith(const char *from_addr,char *to_addr)
{
	//分配一个缓冲区，实际占用18个字节，最后一位用于存放'\0'
	char *addr = (char *)malloc(19 * sizeof(*addr));
	memset(addr,'\0',19);
	//令addr = from_addr
	strcpy(addr+4,from_addr);
	//在addr后面最后添加F
	addr[17] = 'F';
	//对addr将奇数位和偶数位交换
	int i;
	char temp;	//保存中间结果
	for(i = 4; i <= 16; i += 2){
		temp = addr[i];
		addr[i] = addr[i+1];
		addr[i+1] = temp;
	}
	
	//在addr前面加上“91”
	addr[2] = '9';
	addr[3] = '1';
	
	//addr的长度是16，除以2其结果为8，十六进制为"08"
	addr[0] = '0';
	addr[1] = '8';
	
	//将addr复制到to_addr
	strncpy(to_addr,addr,18);
	
	free(addr);
}

/*
* from_phone为需要处理的手机号码，必须以“86”开头，且号码长度（不含“86”）必须是11位，如“8613602433649”
* to_phone保存为对from_phone处理后的结果，保证该缓冲区足够大至少15个字节）
*/
static void phone_dealwith(const char *from_phone,char *to_phone)
{
	//分配一个缓冲区，实际占用13个字节，最后一位用于存放'\0'
	char phone[15];
	memset(phone,'\0',15);
	//令phone = from_phone
	strcpy(phone,from_phone);
	
	//在phone后面最后添加F
	phone[13] = 'F';
	
	//将手机号码奇数位和偶数位交换
	int i;
	char temp;	//保存中间结果
	for(i = 0; i <= 12; i += 2){
		temp = phone[i];
		phone[i] = phone[i+1];
		phone[i+1] = temp;
	}
	
	//将phone复制到to_phone
	strncpy(to_phone,phone,14);
}


/*
* msg：短信息，可以是中文，不过要求编码格式为utf-8且保存在char数组中
* unicode:将短信息处理后的串，包含了短信息的Unicode代码，要求该缓冲区的长度足够长
*
* 将短信息转换为Unicode成功，则返回0，否则返回-1
*/
static int msg_dealwith(const char *msg,char *unicode)
{
	/* 将msg转换为Unicode代码，保存在unicode_msg中 */
	char *inbuf = msg;						//输入缓冲区指针
	unsigned int insize = strlen(msg);	//汉字在在输入编码(fromcode)下所占用的字节数
	
	unsigned char unicode_msg[128];		//保存输出码(tocode)
	memset(unicode_msg,0,128);
	char *outbuf = unicode_msg;			//输出缓冲区指针
	unsigned int outsize =128;				//输出缓冲区长度
	unsigned int avail = outsize;			//记录输出缓冲区剩余空间长度
	
	iconv_t cd;
	cd=iconv_open("UCS-2BE","UTF-8");   //将字符串编码由utf-8转换为UCS-2
	if(cd == (iconv_t)(-1)){
		return -1;
	}
	if((size_t)(-1) == iconv(cd,&inbuf,&insize,&outbuf,&avail)){
		return -1;
	}
	iconv_close(cd);
	
	/* 将unicode_msg以字符串的格式输出到temp缓冲区中 */
	char temp[128];
	memset(temp,0,128);
	int index;
	int outlen = outsize-avail;
	for(index = 0; index < outlen; ++index){
		sprintf(temp+index*2,"%02X ",unicode_msg[index]);
	}
	
	/* 将长度及转换后的Unicode字符串复制到unicode中 */
	//将temp长度的一半即为outsize-avail
	//将temp长度的一半变为两位16进制数并加入到unicode的前部
	sprintf(unicode,"%02X ",outsize-avail);
	//转换后的Unicode字符串复制到unicode+2开始的缓冲区中
	strncpy(unicode+2,temp,(outsize-avail)*2);
	
	return 0;
}


/*
* phone:手机号码
* msg:短信息
* ret:保存处理后的串，保证该缓冲区足够大
* 返回处理后的串的长度的一半，十进制
*/
static int combination(const char *phone,const char *msg,char *ret)
{
	char *str1 = "11000D91";
	char *str2 = "000800";
	
	//临时缓冲区
	size_t len = strlen(str1)+strlen(phone)+strlen(str2)+strlen(msg)+1;
	char *temp = (char *)malloc(len);
	memset(temp,0,len);
	
	size_t index = 0;//指示temp当前的末尾
	//temp前加上字符串11000D91
	strncpy(temp+index,str1,strlen(str1));
	index += strlen(str1);
	
	//将phone追加到temp的末尾
	strncpy(temp+index,phone,strlen(phone));
	index += strlen(phone);
	
	//将"000800"追加到temp的末尾
	strncpy(temp+index,str2,strlen(str2));
	index += strlen(str2);
	
	//将msg追加到temp的末尾
	strncpy(temp+index,msg,strlen(msg));
	index += strlen(msg);
	
	//将temp复制到ret中
	strncpy(ret,temp,index);
	
	//返回temp长度的一半，十进制
	return (index/2);
}



/*
* msg:要发送的短消息，可以是中文，不过要求编码格式为utf-8且保存在char数组中
* phone:接收短消息的手机号码，必须以“86”开头，且号码长度（不含“86”）必须是11位，如“8613602433649”
* addr:为短信中心号码，必须以“86”开头，且号码长度（不含“86”）必须是11位，如“8613800200500”
* ret:存处理后的串，保证该缓冲区足够大
* half:组合处理后的手机号码与处理后的短信息长度的一半，十进制
*
* 将短信息转换为Unicode成功，则返回0，否则返回-1
*/
int build_pdu(const char *msg,const char *phone,const char *addr,char *ret,int *half)
{
	//短信中心号码处理，用字符串my_addr表示处理完后的结果
	char my_addr[19];
	memset(my_addr,0,19);
	msg_center_dealwith(addr,my_addr);
	
	//手机号码处理，用字符串dl_phone表示处理后的结果
	char dl_phone[15];
	memset(dl_phone,0,15);
	phone_dealwith(phone,dl_phone);
	
	//短信息处理，用字符串dl_msg表示处理完后的结果
	char dl_msg[128];
	memset(dl_msg,0,128);
	if(-1 == msg_dealwith(msg,dl_msg))
		return -1;
	
	//组合处理后的手机号码与处理后的短信息，用字符串new_phone表示处理完后的结果
	//并设置half处理后的串的长度的一半
	char new_phone[256];
	memset(new_phone,0,256);
	(*half) = combination(dl_phone,dl_msg,new_phone);
	
	//将处理完后的短信中心号码与组合处理后的手机号码与处理后的短信息后的结果复制到ret中
	strncpy(ret,my_addr,strlen(my_addr));
	strncpy(ret+strlen(my_addr),new_phone,strlen(new_phone));
	
	return 0;
}