ipcfun.c

本代码主要是在SUN操作系统下消息队列的管理

/***************************************
 *文件名:ipcfun.c
 *描  述:进程间通信通用函数
 *编  写:LHZ
 *时  间:2004-05-10
 *函  数:
  -----消息函数-----------
  msg_creat   创建消息队列
  msg_open    打开消息队列
  msg_remove  删除消息队列
  msg_recv    接收消息
  msg_send    发送消息
 ***************************************/

#include "ipcfun.h"
#include "apptool.h"

#ifdef  __MSG_INC
#ifndef _MSG_H
#define _MSG_H

MsgSrv msgsrv;

/*****************************
 * 功 能: 消息服务端对列初始化
 * 返 回: err -1 suc >0 msqid
 *****************************
 */
int msg_init_srv(char *path, char *proc)
{
	if (!path || strlen(path)==0 )
	{
		printf("Msg ftok Path is null.\n");
		return -1;
	}
	if (!proc || strlen(proc)==0 )
	{
		printf("Msg proc name is null.\n");
		return -1;
	}
	strncpy(msgsrv.proc, proc, 50);

	if ( (msgsrv.key = ftok(path, 97)) < 0 )
	{
		msgsrv.key = 0;
		perror("ftok");
		return -1;
	}

	if ( (msgsrv.msqid = msg_creat(msgsrv.key, 0660)) < 0 )
	{
		msgsrv.msqid = 0;
		perror("msgget");
		return -2;
	}

	return msgsrv.msqid;
}

/*****************************
 * 功 能: 消息客户端对列初始化
 * 返 回: err -1 suc >0 msqid
 *****************************
 */
int msg_init_clt(char *path, char *proc)
{
	if (!path || strlen(path)==0 )
	{
		printf("Msg ftok Path is null.\n");
		return -1;
	}
	if (!proc || strlen(proc)==0 )
	{
		printf("Msg proc name is null.\n");
		return -1;
	}
	strncpy(msgsrv.proc, proc, 50);

	if ( (msgsrv.key = ftok(path, 97)) < 0 )
	{
		msgsrv.key = 0;
		perror("ftok");
		return -1;
	}

	if ( (msgsrv.msqid = msg_open(msgsrv.key, 0660)) < 0 )
	{
		msgsrv.msqid = 0;
		perror("msgget");
		return -2;
	}

	return msgsrv.msqid;
}

/*****************************
 * 功 能: 删除消息服务端对列
 * 返 回:
 *****************************
 */
void msg_down_srv()
{
	if (msg_remove(msgsrv.msqid) < 0)
	{
		sleep(10);
		msg_remove(msgsrv.msqid);
	}

	return;
}

/*****************************
 * 功 能: 接收消息数据
 * 返 回: err -1 suc >0 msglevel
 *****************************
 */
int msg_data_recv(long type, char *buf)
{
	/*if (type < 0) type = 0;*/
	msgsrv.msgbuf.msg_type = type;
	msgsrv.msgbuf.msg_level = -1;
	if ( msg_recv(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
	{
		if ( (msgsrv.msqid = msg_open(msgsrv.key, 0660)) < 0 )
		{
			perror("Re msgget");
			return -2;
		}
		if ( msg_recv(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
		{
			perror("msgrcv");
			return -1;
		}
	}

	if (buf) strcpy(buf, msgsrv.msgbuf.msg_data);

	return msgsrv.msgbuf.msg_level;
}

/*****************************
 * 功 能: 发送消息数据
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_data_send(long level, char *buf)
{
	if (level < 0) level = 0;

	msgsrv.msgbuf.msg_type = (long)getpid();
	msgsrv.msgbuf.msg_level = level;

	sprintf(msgsrv.msgbuf.msg_data, "%s:", msgsrv.proc);
	strncat(msgsrv.msgbuf.msg_data, buf, (MSG_DATA_SIZE - strlen(msgsrv.proc)-1));

	if ( msgsrv.msqid == 0 || msg_send(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
	{
		if ( (msgsrv.msqid = msg_open(msgsrv.key, 0660)) < 0 )
		{
			msgsrv.msqid = 0;
			perror("Re msgget");
			return -2;
		}
		if ( msg_send(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
		{
			perror("msgsnd");
			return -1;
		}
	}

	return 0;
}

/*****************************
 * 功 能: 发送消息数据(不阻塞)
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_data_sendto(long level, char *buf)
{
	if (level < 0) level = 0;

	msgsrv.msgbuf.msg_type = (long)getpid();
	msgsrv.msgbuf.msg_level = level;

	sprintf(msgsrv.msgbuf.msg_data, "%s:", msgsrv.proc);
	strncat(msgsrv.msgbuf.msg_data, buf, (MSG_DATA_SIZE - strlen(msgsrv.proc)-1));

	if (msgsrv.msqid == 0 || msg_sendto(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
	{
		if ( msgsrv.msqid ==0 &&
		    (msgsrv.msqid = msg_open(msgsrv.key, 0660)) < 0 )
		{
			msgsrv.msqid = 0;
			perror("Re msgget");
			return -2;
		}
		if ( msg_sendto(msgsrv.msqid, &msgsrv.msgbuf) < 0 )
		{
			msgsrv.msqid = 0;
			perror("msgsnd");
			return -1;
		}
		perror("msgsnd");
		return -1;
	}

	return 0;
}

/*****************************
 * 功 能: 创建消息队列
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_creat(key_t key, int msgflag)
{
	return(msgget(key, IPC_CREAT|IPC_EXCL|msgflag));
}

/*****************************
 * 功 能: 打开消息队列
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_open(key_t key, int msgflag)
{
	return(msgget(key, msgflag));
}

/*****************************
 * 功 能: 删除消息队列
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_remove(int id)
{
	return(msgctl(id, IPC_RMID ,0));
}

/*****************************
 * 功 能: 发送消息
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_send(int id, MsgBuf *pMsg)
{
	int len;
	
	if (id == 0) return -100;
	
	len = sizeof(MsgBuf) - sizeof(long);

	return(msgsnd(id, (const void *)pMsg, len, 0));
}

/*****************************
 * 功 能: 发送消息(不阻塞)
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_sendto(int id, MsgBuf *pMsg)
{
	int len;

	if (id == 0) return -100;

	len = sizeof(MsgBuf) - sizeof(long);

	return(msgsnd(id, (const void *)pMsg, len, IPC_NOWAIT));
}

/*****************************
 * 功 能: 接收消息
 * 返 回: err -1 suc >0
 *****************************
 */
int msg_recv(int id, MsgBuf *pMsg)
{
	int len, n;

	len = sizeof(MsgBuf) - sizeof(long);
	do
	{
		n = msgrcv(id, (void *)pMsg, len, pMsg->msg_type, 0);
	}while( n ==-1 && errno == EINTR);

	return n;
}

/*****************************
 * 功 能: 消息初始化封装
   		(对外相当于接口函数,用于客户端)
 * 返 回: err < 0 suc ==0
 *****************************
 */
int msg_initfp(char *inifile, char *pname)
{
	char rtnstr[255],inistr[51];
	char path[255],proc[51];

	if (inifile && strlen(inifile) > 0)
	{
		strncpy(inistr, inifile, 50);
	}
	else
	{
		strcpy(inistr, "msginit.ini");
	}

	if (ini_getkey(inistr,"msg","path",rtnstr)< 0) return -1;
	strncpy(path, rtnstr, 50);

	if (pname) strncpy(proc, pname, 50);

	if (msg_init_clt(path, proc) < 0)
	{
		printf("Msg init failed.\n");
		return -2;
	}

	printf("Msg init success.\n");

	return 0;
}

#endif   /*_MSG_H*/
#endif   /*__MSG_INC*/


#ifdef  __SHM_INC
#ifndef _SHM_H
#define _SHM_H

/*****************************
 * 功 能: 创建共享内存
 * 参 数: size  >0 新创建 0 打开
 * 返 回: err < 0 suc ==0
 *****************************
 */
int shm_create(key_t key, size_t size)
{
	if (size > 0)
	{	
		if (size < MIN_SHMSIZE) size = MIN_SHMSIZE;
		return(shmget(key, size, IPC_CREAT|IPC_EXCL|0666));
	}
	else
		return(shmget(key, 0, 0));
}

/*****************************
 * 功 能: 连接共享内存
 * 参 数: flag  RO_IPC 只读 RW_IPC 可写
 * 返 回: 
 *****************************
 */
void *shm_link(key_t key, int shmid, int flag)
{
	if (shmid <= 0 && key != 0)
		if ((shmid = shm_create(key, 0)) == -1)
			return NULL;
	else if (shmid <= 0) return NULL;
		
	if (flag == RO_IPC)
		return(shmat(shmid, NULL, SHM_RDONLY));
	else
		return(shmat(shmid, NULL, 0));
}

/*****************************
 * 功 能: 脱离共享内存
 * 参 数: 
 * 返 回: 
 *****************************
 */
int shm_unlink(void *paddr)
{
	return(shmdt(paddr));
}

/*****************************
 * 功 能: 删除共享内存
 * 参 数: 
 * 返 回: 
 *****************************
 */
int shm_remove(key_t key, int shmid)
{
	if (shmid <= 0 && key != 0)
		if ((shmid = shm_create(key, 0)) == -1)
			return -1;
	else if (shmid <= 0) return -1;
	
	return(shmctl(shmid,IPC_RMID,NULL));
}

#endif   /*_SHM_H*/
#endif   /*__SHM_INC*/


#ifdef  __SEM_INC
#ifndef _SEM_H
#define _SEM_H

/*****************************
 * 功 能: 创建信号量集
 * 参 数: semnum >0 创建 0打开
 * 返 回: 
 *****************************
 */
int sem_create(key_t key, int semnum)
{
	if (semnum == 0)
		return(semget(key, 0, 0666));
	else
		return(semget(key, semnum, IPC_CREAT|IPC_EXCL|0666));
}

/*****************************
 * 功 能: 删除信号量集
 * 参 数: 
 * 返 回: 
 *****************************
 */
int sem_remove(key_t key)
{
	int 	semid;

	if ((semid = sem_create(key, 0)) == -1)
			return -1;

	return(semctl(semid, 0, IPC_RMID, 0));
}

/*****************************
 * 功 能: 锁定一个信号量
 * 参 数: flag 是否立即返回WAIT_IPC NOWT_IPC
 * 返 回: 
 *****************************
 */
int sem_lock(key_t key, int semnum, int flag)
{
	int semid;
	struct sembuf sem_lock = {0, -1, IPC_NOWAIT};
	
	if (flag == WAIT_IPC) sem_lock.sem_flg = 0;
	
	if ((semid = sem_create(key, 0)) == -1)
		return -1;
		
	sem_lock.sem_num = semnum;
	
	return(semop(semid, &sem_lock, 1));	
}

/*****************************
 * 功 能: 解锁一个信号量
 * 参 数: flag 是否立即返回WAIT_IPC NOWT_IPC
 * 返 回: 
 *****************************
 */
int sem_unlock(key_t key, int semnum, int flag)
{
	int semid;
	struct sembuf sem_lock = {0, 1, IPC_NOWAIT};
	
	if (flag == WAIT_IPC) sem_lock.sem_flg = 0;
	
	if ((semid = sem_create(key, 0)) == -1)
		return -1;
		
	sem_lock.sem_num = semnum;
	
	return(semop(semid, &sem_lock, 1));	
}

/*****************************
 * 功 能: 使用一个信号量值
 * 参 数: flag 是否立即返回WAIT_IPC NOWT_IPC
 * 返 回: 
 *****************************
 */
int sem_valused(key_t key, int semnum, int flag)
{
	int semid;
	struct sembuf sem_lock = {0, -1, IPC_NOWAIT};
	
	if (flag == WAIT_IPC)	sem_lock.sem_flg = 0;
	
	if ((semid = sem_create(key, 0)) == -1)
		return -1;

	sem_lock.sem_num = semnum;
	
	return(semop(semid, &sem_lock, 1));	
}

/*****************************
 * 功 能: 释放一个信号量值
 * 参 数: flag 是否立即返回WAIT_IPC NOWT_IPC
 * 返 回: 
 *****************************
 */
int sem_valfree(key_t key, int semnum, int flag)
{
	int semid;
	struct sembuf sem_lock={0, 1, IPC_NOWAIT};
	
	if (flag == WAIT_IPC)	sem_lock.sem_flg = 0;
	
	if ((semid = sem_create(key, 0)) == -1)
		return -1;
	sem_lock.sem_num = semnum;
	
	return(semop(semid, &sem_lock, 1));	
}

/*****************************
 * 功 能: 设置一个信号量值
 * 参 数: 
 * 返 回: 
 *****************************
 */
int sem_setval(key_t key, int semnum, int semval)
{
	int 	semid;
	union semun usem;
	
	if ((semid = sem_create(key, 0)) == -1)
			return -1;
	
	usem.val = semval;
	
	return(semctl(semid, semnum, SETVAL, usem));
}

/*****************************
 * 功 能: 获得一个信号量值
 * 参 数: 
 * 返 回: 
 *****************************
 */
int sem_getval(key_t key, int semnum)
{
	int 	semid;
	if ((semid = sem_create(key, 0)) == -1)
		return -1;
	
	return(semctl(semid, semnum, GETVAL, 0));
}

#endif   /*_SEM_H*/
#endif   /*__SEM_INC*/