信号量API和内存映射空间API使用中碰到的问题，高手帮忙看看，如果能解决愿意200分相送

Question

设计一系统，由一个函数和一个服务程序组成
-----------------------------------------------
/* 服务程序 */
创建 消费者 信号量，初始值为0
创建 生产者 信号量，初始值为1
创建 句柄系统内存映射空间，并初始化 
while(1)
{
消费者 信号量 P操作
swicth( 句柄系统 内存映射空间.*pcIpcType )
{
case 'P':
打开 信号量 ( 句柄系统 内存映射空间.*plRequestHandle )

break;
...

if( 打开 失败 )
显示出错信息
}
...

写回数据 句柄系统 内存映射空间 至 进程空间
生产者 信号量 V操作
}
-----------------------------------------------
/* 函数 */
创建 用户信号量(key=参数ipckey)
if( 创建失败 )
返回 出错信息
打开 生产者 信号量
打开 消费者 信号量
打开 句柄系统 内存映射空间
生产者 信号量 P操作
设置 ( 句柄系统 内存映射空间.*pcIpcType ) = 'P'
设置 ( 句柄系统 内存映射空间.*plRequestHandle ) = key
写回数据 句柄系统 内存映射空间 至 进程空间
消费者 信号量 V操作
打开 句柄系统 内存映射空间
if( ( 句柄系统 内存映射空间.*pcIpcType ) = 'P' )
返回 出错信息
写回数据 句柄系统 内存映射空间 至 进程空间
-----------------------------------------------
服务程序先于函数所在的程序先运行
现在出现的问题是：
1. 有时候 信号量( 句柄系统 内存映射空间.*pcIpcType )在 函数里创建成功，但是在 服务程序里 打开 信号量 ( 句柄系统 内存映射空间.*plRequestHandle )。问题出现的概率大概是25%。
2. 服务程序里 重新设置的( 句柄系统 内存映射空间.*pcIpcType )和( 句柄系统 内存映射空间.*plRequestHandle )没有传回函数中来。
请问
1. 为什么会这样出现像问题1那样有时候成功有时候失败的情况
2. 内存映射空间里的更新信息为什么会没有被函数读到（更新信息已使用FlushViewOfFile刷新了）
-----------------------------------------------
具体程序如下：
-----------------------------------------------
/* iIPC.Server.c */
#include <stdio.h>#include <windows.h>#include "../iLibX/include/LibX.h"
#include "../iLibX/include/TypeX.h"
#include "../iLibX/include/TimeX.h"
#include "../iLibX/include/LogX.h"#define IPCSERVER_HANDLESYSTEM_AMOUNT 1024#define DEBUG TRUE
#define FILENAME_LOGFILE "debug.log"char gacTimeStringBuffer[256];int main()
{
HANDLE hSemaphoreConsumer;
HANDLE hSemaphoreProducer;
HANDLE hFileMappingHandleSystem;
HANDLE h;

DWORD dwWaitResult;

LPVOID pvHandleSystem;
char *pcIpcType;
long *plRequestHandle;
long *plHandleSystem;

long l;
char acNameBuffer[11];

memset( gacTimeStringBuffer , 0x00 , sizeof( gacTimeStringBuffer ) );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | ----------------------------------------------------------------------\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | iIPC Server v1.0 builder 000000\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | iIPC服务 开启 - %s\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ) );

/* 创建 消费者 信号量 */
hSemaphoreConsumer = CreateSemaphore( NULL,
0,
10,
"iIPCSystem_ConsumerSemaphore" );
if (hSemaphoreConsumer == NULL)
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 消费者 信号量 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

return -1;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 消费者 信号量 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
} /* 创建 生产者 信号量 */
hSemaphoreProducer = CreateSemaphore( NULL,
1,
10,
"iIPCSystem_ProducerSemaphore" );
if (hSemaphoreProducer == NULL)
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 生产者 信号量 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

return -1;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 生产者 信号量 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

Answer 1

/* 创建 句柄系统 内存映射空间 */
hFileMappingHandleSystem = CreateFileMapping( INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0L,
( IPCSERVER_HANDLESYSTEM_AMOUNT + 1 ) * sizeof( long ) + 1 ,
"iIPCSystem_HandleFileMapping" );
if (hFileMappingHandleSystem == NULL)
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 句柄系统 内存映射空间量 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

return -1;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 创建 句柄系统 内存映射空间量 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
} /* 映射 句柄系统 内存映射空间 至 进程空间 */
pvHandleSystem = MapViewOfFile( hFileMappingHandleSystem,
FILE_MAP_ALL_ACCESS,
0,
0,
0 );
if( pvHandleSystem == NULL )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 映射 句柄系统 内存映射空间 至 进程空间 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

return -1;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 映射 句柄系统 内存映射空间 至 进程空间 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

/* 句柄系统 内存映射空间 初始化 */
memset( pvHandleSystem , 0x00 , ( IPCSERVER_HANDLESYSTEM_AMOUNT + 1 ) * sizeof( long ) + 1 );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 句柄系统 内存映射空间 初始化\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ ); /* 写回数据 句柄系统 内存映射空间 至 进程空间 */
FlushViewOfFile( pvHandleSystem , 0 ); /* 解除映射 句柄系统 内存映射空间 至 进程空间 */
UnmapViewOfFile( pvHandleSystem );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 解除映射 句柄系统 内存映射空间 至 进程空间\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

while(1)
{
/* 消费者 信号量 P操作 */
dwWaitResult = WaitForSingleObject( hSemaphoreConsumer , INFINITE );

if( dwWaitResult == WAIT_FAILED )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 消费者 信号量 P操作 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

break;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | --- 处理开始 ------------------------------\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

WriteLog( FILENAME_LOGFILE,
"%s | %04d | 消费者 信号量 P操作 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

/* 映射 句柄系统 内存映射空间 至 进程空间 */
pvHandleSystem = MapViewOfFile( hFileMappingHandleSystem,
FILE_MAP_ALL_ACCESS,
0,
0,
0 );
if( pvHandleSystem == NULL )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 映射 句柄系统 内存映射空间 至 进程空间 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

goto _GOTO_OVER;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 映射 句柄系统 内存映射空间 至 进程空间 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

/* 定位数据指针 至 内存映射空间 */
pcIpcType = (char *)pvHandleSystem ;
plRequestHandle = (long *)( pcIpcType + 1 ) ;
plHandleSystem = plRequestHandle + 1 ;

/* 如果 句柄系统 内存映射空间 信息头数据无效，结束本次处理 */
if(
*pcIpcType != 'P'
&&
*pcIpcType != 'M'
&&
*pcIpcType != 'G'
&&
*pcIpcType != 'p'
&&
*pcIpcType != 'm'
&&
*pcIpcType != 'g'
&&
*plRequestHandle <= 0
)
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 句柄系统 内存映射空间 信息头数据无效，请求类型[%c] 请求KEY[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle );

*pcIpcType = ' ' ;
*plRequestHandle = 0 ;

/* 生产者 信号量 V操作 */
if( ReleaseSemaphore( hSemaphoreProducer , 1 , NULL) )
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 生产者 信号量 V操作 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

goto _GOTO_OVER;
}

/* 构造 请求KEY 的 字符数组变量 */
memset( acNameBuffer , 0x00 , sizeof( acNameBuffer ) );
sprintf( acNameBuffer , "%ld" , *plRequestHandle );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 输入 请求类型[%c] 请求KEY[%ld][%s]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle,
acNameBuffer );

/* 分支 请求类型 */
switch( *pcIpcType )
{
case 'P':
case 'M':
case 'G':
/* 查找 句柄系统 内存映射空间 空闲单元 */
for( l=0 ; l<IPCSERVER_HANDLESYSTEM_AMOUNT ; l++ )
if( *( plHandleSystem + l ) == 0 )
break;

if( l < IPCSERVER_HANDLESYSTEM_AMOUNT )
{
switch( *pcIpcType )
{
case 'P':
/* 打开 用户信号量（该句柄变成全局句柄） */
h = OpenSemaphore( SEMAPHORE_ALL_ACCESS , TRUE , acNameBuffer );

break;
case 'M':
case 'G':
/* 打开 用户内存映射空间（该句柄变成全局句柄） */
h = OpenFileMapping( FILE_MAP_ALL_ACCESS , TRUE , acNameBuffer );

break;
default:
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 请求类型[%c] 请求KEY[%ld][%s] 无效\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle,
acNameBuffer );

goto _GOTO_OVER;
}

if( h == NULL )
{
/* 注册句柄 失败 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 注册 句柄 失败，打开句柄时发生错误，GetLastError[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() ); /* 置 句柄系统 内存映射空间 信息头数据 为 注册失败 */
*pcIpcType = 'F' ;
*plRequestHandle = GetLastError() ;
}
else
{
/* 注册句柄 成功 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 注册 句柄 成功，索引[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
l );

/* 注册句柄 */
*( plHandleSystem + l ) = *plRequestHandle ;

/* 置 句柄系统 内存映射空间 信息头数据 为 注册成功 */
*pcIpcType = 'S' ;
*plRequestHandle = 0 ;
}
}
else
{
/* 注册句柄 失败，没有有空闲单元 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 注册句柄 失败，空闲单元未找到\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

/* 置 句柄系统 内存映射空间 信息头数据 为 空闲单元未找到 */
*pcIpcType = 'F' ;
*plRequestHandle = 1 ;
}

break;

Answer 2

case 'p':
case 'm':
case 'g':
/* 查找 句柄系统 内存映射空间 原数据单元 */
for( l=0 ; l<IPCSERVER_HANDLESYSTEM_AMOUNT ; l++ )
if( *( plHandleSystem + l ) == *plRequestHandle )
break;

if( l < IPCSERVER_HANDLESYSTEM_AMOUNT )
{
switch( *pcIpcType )
{
case 'p':
/* 打开 用户信号量 */
h = OpenSemaphore( SEMAPHORE_ALL_ACCESS , TRUE , acNameBuffer );

break;
case 'm':
case 'g':
/* 打开 用户内存映射空间 */
h = OpenFileMapping( SEMAPHORE_ALL_ACCESS , TRUE , acNameBuffer );

break;
default:
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 请求类型[%c] 请求KEY[%ld] 请求KEY字符数组[%s] 无效\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle,
acNameBuffer );

goto _GOTO_OVER;
}

if( h == NULL )
{
/* 注册句柄 失败，打开句柄发生错误 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 撤消 句柄 失败，打开句柄时发生错误，GetLastError[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() ); /* 置 句柄系统 内存映射空间 信息头数据 为 注册失败 */
*pcIpcType = 'F' ;
*plRequestHandle = GetLastError() ;
}
else
{
/* 注册句柄 成功 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 撤消 句柄 成功，索引[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
l );

/* 注册句柄 */
*( plHandleSystem + l ) = *plRequestHandle ;

/* 置 句柄系统 内存映射空间 信息头数据 为 注册成功 */
*pcIpcType = 'S' ;
*plRequestHandle = 0 ; /* 关闭句柄 */
CloseHandle( h );

/* 撤消句柄 */
*( plHandleSystem + l ) = 0 ;

/* 置 句柄系统 内存映射空间 信息头数据 为 撤消成功 */
*pcIpcType = 'S' ;
*plRequestHandle = 0 ;

}
}
else
{
/* 没有找到原来的单元 */
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 撤消 句柄 失败，原数据单元未找到\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

/* 置 句柄系统 内存映射空间 信息头数据 为 空闲单元未找到 */
*pcIpcType = 'F' ;
*plRequestHandle = 1 ;
}

break;
default:
if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 请求类型[%c] 请求KEY[%ld] 无效\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle );

break;
}_GOTO_OVER: if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 输出 请求类型[%c] 请求KEY[%ld]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
*pcIpcType,
*plRequestHandle ); /* 写回数据 句柄系统 内存映射空间 至 进程空间 */
FlushViewOfFile( pvHandleSystem , 0 );

/* 解除映射 句柄系统 内存映射空间 至 进程空间 */
UnmapViewOfFile( pvHandleSystem );

if( DEBUG )
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 解除映射 句柄系统 内存映射空间 至 进程空间\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );

/* 生产者 信号量 V操作 */
if( !ReleaseSemaphore( hSemaphoreProducer , 1 , NULL) )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 生产者 信号量 V操作 失败，GetLastError[%d]\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__,
GetLastError() );

break;
}
else if( DEBUG )
{
WriteLog( FILENAME_LOGFILE,
"%s | %04d | 生产者 信号量 V操作 成功\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

WriteLog( FILENAME_LOGFILE,
"%s | %04d | --- 处理结束 ------------------------------\n",
GetLocalTimeString( gacTimeStringBuffer , 256 , "%Y-%m-%d %H:%M:%S" ),
__LINE__ );
}

/* 关闭 所有工作句柄 */
CloseHandle( hSemaphoreConsumer );
CloseHandle( hSemaphoreProducer );
CloseHandle( hFileMappingHandleSystem );

return 0;
}
-----------------------------------------------
/* 函数 IPCCreateSemaphore */
_IPC_ID_T IPCCreateSemaphore( _IPC_KEY_T ipckey , _IPC_SEMVAL_T ipcsvSemaphoreValue )
{
HANDLE hSemaphoreConsumer;
HANDLE hSemaphoreProducer;
HANDLE hFileMappingHandleSystem;
HANDLE h;

DWORD dwWaitResult;

LPVOID pvHandleSystem;
char *pcIpcType;
long *plRequestHandle;
long *plHandleSystem;

char acNameBuffer[11];

memset( acNameBuffer , 0x00 , sizeof( acNameBuffer ) );
sprintf( acNameBuffer , "%ld" , ipckey );

Answer 3

/* 创建 用户信号量 */
h = CreateSemaphore ( NULL,
ipcsvSemaphoreValue,
/* (long)( (unsigned long)(-1) / 2 ), */
100,
acNameBuffer ); if( h == NULL )
return IPC_SEMAPHORE_ERROR_CANT_CREATE;
else if( GetLastError() == ERROR_ALREADY_EXISTS )
return IPC_SEMAPHORE_RETURN_EXIST; /********* 打开 各工作IPC资源 *********/ /* 打开 生产者 信号量 */
hSemaphoreProducer = OpenSemaphore( SEMAPHORE_ALL_ACCESS , TRUE , "iIPCSystem_ProducerSemaphore" );

if (hSemaphoreProducer == NULL)
return IPC_SEMAPHORE_ERROR_CANT_OPEN_PRODUCER;

/* 打开 消费者 信号量 */
hSemaphoreConsumer = OpenSemaphore( SEMAPHORE_ALL_ACCESS , TRUE , "iIPCSystem_ConsumerSemaphore" );

if (hSemaphoreConsumer == NULL)
return IPC_SEMAPHORE_ERROR_CANT_OPEN_CONSUMER;

/* 打开 句柄系统 内存映射空间 */
hFileMappingHandleSystem = OpenFileMapping( FILE_MAP_ALL_ACCESS , TRUE , "iIPCSystem_HandleFileMapping" );

if( hFileMappingHandleSystem == NULL)
return IPC_SEMAPHORE_ERROR_CANT_OPEN_HANDLESYSTEM;

/********* 设置 句柄系统 内存映射空间 数据头信息 *********/

/* 生产者 信号量 P操作 */
dwWaitResult = WaitForSingleObject( hSemaphoreProducer , INFINITE );

if( dwWaitResult == WAIT_FAILED )
return IPC_SEMAPHORE_ERROR_CANT_PRODUCER_P;

/* 映射 句柄系统 内存映射空间 至 进程空间 */
pvHandleSystem = MapViewOfFile( hFileMappingHandleSystem,
FILE_MAP_ALL_ACCESS,
0,
0,
0 );
if( pvHandleSystem == NULL )
return IPC_SEMAPHORE_ERROR_CANT_MAPPING_HANDLESYSTEM;

/* 定位数据指针 至 内存映射空间 */
pcIpcType = (char *)pvHandleSystem ;
plRequestHandle = (long *)( pcIpcType + 1 ) ;
plHandleSystem = plRequestHandle + 1 ;

/* 句柄系统 内存映射空间 数据头信息 */
*pcIpcType = 'P' ;
*plRequestHandle = (long)ipckey ;

/* 写回数据 句柄系统 内存映射空间 至 进程空间 */
FlushViewOfFile( pvHandleSystem , 0 );

/* 解除映射 句柄系统 内存映射空间 至 进程空间 */
UnmapViewOfFile( pvHandleSystem );

/* 关闭 句柄系统 内存映射空间 句柄 */
CloseHandle( hFileMappingHandleSystem );

/* 消费者 信号量 V操作 */
if( !ReleaseSemaphore( hSemaphoreConsumer , 1 , NULL) )
return IPC_SEMAPHORE_ERROR_CANT_CONSUMER_V; /********* 检查 句柄系统 内存映射空间 数据头信息 返回值 *********/

/* 打开 句柄系统 内存映射空间 */
hFileMappingHandleSystem = OpenFileMapping( FILE_MAP_ALL_ACCESS , TRUE , "iIPCSystem_HandleFileMapping" );

if( hFileMappingHandleSystem == NULL)
return IPC_SEMAPHORE_ERROR_CANT_OPEN_HANDLESYSTEM;

/* 映射 句柄系统 内存映射空间 至 进程空间 */
pvHandleSystem = MapViewOfFile( hFileMappingHandleSystem,
FILE_MAP_ALL_ACCESS,
0,
0,
0 );
if( pvHandleSystem == NULL )
return IPC_SEMAPHORE_ERROR_CANT_MAPPING_HANDLESYSTEM;

/* 定位数据指针 至 内存映射空间 */
pcIpcType = (char *)pvHandleSystem ;
plRequestHandle = (long *)( pcIpcType + 1 ) ;
plHandleSystem = plRequestHandle + 1 ; /* 句柄系统 内存映射空间 数据头信息 */
if( *pcIpcType == 'F' )
return 0 - ( *plRequestHandle + 10000 ) ;

/* 写回数据 句柄系统 内存映射空间 至 进程空间 */
FlushViewOfFile( pvHandleSystem , 0 );

/* 解除映射 句柄系统 内存映射空间 至 进程空间 */
UnmapViewOfFile( pvHandleSystem ); return (long)h ;
}

Answer 4

这里的程序排版全乱了 可以看看这里
http://bbs.chinaunix.net/forum/23/20040929/416172.html

Answer 5

太乱了，不好看，请整理好发至
[email protected]