基于Windows的多线程UDP通信（VS2010）

extern "C" {
#include "udpMediaService.h"
}

#include <windows.h>
#include <string> 
#include <vector>
#include <time.h>

using namespace std;

bool FindOrCreateDirectory( const char* pszPath )
{
    WIN32_FIND_DATA fd;
    HANDLE hFind = ::FindFirstFile( pszPath, &fd );
    while( hFind != INVALID_HANDLE_VALUE )
    {
        if ( fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
            return true;
    }

    if ( !::CreateDirectory( pszPath, NULL ) )
    {
        //char szDir[MAX_PATH];
        //sprintf_s( szDir, sizeof(szDir), "创建目录[%s]失败,请检查权限", pszPath );
        //Output("the error is %s", szDir);
        //return false;
    }

    return true;
}

// 遍历目录
bool CheckDirectory( char* pszPath )
{
    vector< std::string > vtPath;

    const char* sep = "\\/";
    char* next_token;
    char* token =  strtok_s( pszPath, sep, &next_token);
    while( token != NULL )
    {
        vtPath.push_back( token );
        token = strtok_s(NULL, sep, &next_token);
    }

    if ( vtPath.size() > 0 )
    {
        if ( vtPath[0] == "." )
            vtPath.erase( vtPath.begin() );
    }

    // 核查所有路径是否存在
    std::string strCurPath;
    for( size_t i = 0; i  < (int)vtPath.size(); ++i )
    {
        strCurPath += vtPath[i];
        strCurPath += ‘\\‘;

        if ( !FindOrCreateDirectory( strCurPath.c_str() ) )
        {
            return false;
        }
    }

    return true;
}

DWORD WINAPI mediaRecvPthread(LPVOID pM)
{
	char buffer[BUFFER_SIZE] = {0};
	int mediaRecvLen = -1;
	int mediaRecvStatus = 1;
	char mediaPath[128] = {0};
	int err;
	BOOL bDontLinger = FALSE;
	BOOL bReuseaddr = TRUE;
	int nNetTimeout = TIME; //阻塞
	int recvAddrLen = 0;
	char localip[20];
	char filePath[128] = {0};
	MEDIAPATH *mediaValue = (MEDIAPATH *)pM;
	int port = atoi(mediaValue->mediaValue);
	memcpy(filePath, mediaValue->filePath, sizeof(mediaValue->filePath));
	//unsigned long ul = 1;
	SOCKET mediaRecvSock;
	struct sockaddr_in mediaRecvAddr;
	struct sockaddr_in mediaRecvFromAddr;
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);
	printf("port is %d.\n", port);
	printf("filePath is %s.\n", filePath);
	mediaRecvSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	//if (SOCKET_ERROR == ioctlsocket(recvSocket, FIONBIO, (unsigned long *)&ul))  //设置成非阻塞函数
	//{
	//	printf("ioctlsocket fiald\n");
	//	return -1;
	//}

	memset(&mediaRecvAddr, 0, sizeof(recvAddr));
	mediaRecvAddr.sin_family = AF_INET;
	mediaRecvAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	//mediaRecvAddr.sin_addr.S_un.S_addr = inet_addr(SERVERIP);
	mediaRecvAddr.sin_port = htons(port);
	recvAddrLen = sizeof(mediaRecvAddr);

	if (0 != bind(mediaRecvSock, (SOCKADDR *)&mediaRecvAddr, recvAddrLen))
	{
		printf("mediaRecvInit Bind filed!\n");
		return -1;
	}

	setsockopt(mediaRecvSock, SOL_SOCKET, SO_DONTLINGER, (const char*)&bDontLinger, sizeof(BOOL));
	setsockopt(mediaRecvSock, SOL_SOCKET, SO_REUSEADDR, (const char*)&bReuseaddr, sizeof(BOOL));
	setsockopt(mediaRecvSock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&nNetTimeout, sizeof(BOOL));

	FILE *mediaFp = fopen(filePath, "wb");

	while(mediaRecvStatus)
	{
		mediaRecvLen = recvfrom(mediaRecvSock, buffer, sizeof(buffer), 0, (SOCKADDR *)&mediaRecvFromAddr, &recvAddrLen);

		if (mediaRecvLen = SOCKET_ERROR)
		{
			err = WSAGetLastError();
			if (err == WSAEWOULDBLOCK)
			{
				continue;
			}
			else if (err == WSAETIMEDOUT) //超时
			{
				printf("recv timeout\n");
				break;
			}
			else if (err == WSAENETDOWN) //连接断开
			{
				printf("recv connection break\n");
				break;
			}
			else //其他错误
				printf("other error\n");
			break;
		}
		else
		{
			fwrite(buffer, sizeof(char), mediaRecvLen, mediaFp);
		}
	}
	fclose(mediaFp);
	closesocket(mediaRecvSock);
	WSACleanup();

	return 0;
}

//XXX:使用带头结点的单向链表   存放用户信息

int memoryError(USERINFO *p) //判断内存是否申请成功
{
	if (p == NULL) {
		printf("MEMORY ERROR!");
		return 1;
	}
	return 0;
}

int creatUserList(USERINFO *head) {
	if (memoryError(head))
		return -1;
	head->next = NULL;
}

int addUser(USERINFO *head, MEDIAINFO data) //始终在表头插入
{
	USERINFO * new_create = (USERINFO *)malloc(sizeof(USERINFO));
	if (memoryError(new_create))
		return -1;
	new_create->mediaInfo = data;
	new_create->next = head->next;
	head->next = new_create;
}

int delUser(USERINFO *head, char name[10]) {
	USERINFO *q = head;
	USERINFO *p = head->next;
	while (p != NULL) {
		if (strcmp((p->mediaInfo).uid, name) == 0)
			break;
		q = p;
		p = p->next;
	}
	if (p == NULL) {
		printf("删除用户失败\n");
		return -1;
	}
	q->next = p->next;
	free(p);
	p = NULL;
}

int findUser(USERINFO *head, char name[10]) {
	USERINFO *p = head->next;
	while (p != NULL) {
		if (strcmp((p->mediaInfo).uid, name) == 0)
			return 0;
		p = p->next;
	}
	if (p == NULL)
		return -1;
}

int getMediaPort()
{
	SOCKET s;
	int port;
	struct sockaddr_in addr;

	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

	memset(&addr, 0, sizeof(addr));

	addr.sin_family = AF_INET;
	addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	for(port = 5500; port < 65535; port++)
	{
		addr.sin_port = htons(port);
		if (0 == bind(s, (struct sockaddr *)&addr, sizeof(addr)))
		{
			break;
		}
	}
	closesocket(s);

	return port != 65535 ? port : -1;
}

int getNowTime(char *nowTime)
{
	char acYear[5] = {0};
	char acMonth[5] = {0};
	char acDay[5] = {0};
	char acHour[5] = {0};
	char acMin[5] = {0};
	char acSec[5] = {0};

	time_t now;
    struct tm* timenow;
    
    time(&now);
    timenow = localtime(&now);

    strftime(acYear,sizeof(acYear),"%Y",timenow);
    strftime(acMonth,sizeof(acMonth),"%m",timenow);
    strftime(acDay,sizeof(acDay),"%d",timenow);
    strftime(acHour,sizeof(acHour),"%H",timenow);
    strftime(acMin,sizeof(acMin),"%M",timenow);
    strftime(acSec,sizeof(acSec),"%S",timenow);

	strncat(nowTime, acYear, 4);
	strncat(nowTime, acMonth, 2);
	strncat(nowTime, acDay, 2);
	strncat(nowTime, acHour, 2);
	strncat(nowTime, acMin, 2);
	strncat(nowTime, acSec, 2);

	return 0;
}

int changeStr(const char *str1, const char *str2, const char *str3, const char *str4, char *outstr)
{
	strncat(outstr, str1, strlen(str1));
	strncat(outstr, "//", 2);
	strncat(outstr, str2, strlen(str2));
	strncat(outstr, str3, strlen(str3));
	strncat(outstr, str4, strlen(str4));

	return 0;
}

//DWORD WINAPI ThreadFun(LPVOID pM)
//{
//	printf("子线程ID号为：%d\n", GetCurrentThreadId());
//	return 0;
//}

int mediaRecvPthreadInit(MEDIAPATH *mediaValue)
{
	HANDLE mediaRecvHandle = NULL;
	mediaRecvHandle = CreateThread(NULL, 0, mediaRecvPthread, mediaValue, 0, NULL);
	if (NULL == mediaRecvHandle)
	{
	    printf("Create Thread mediaRecvPthread error\n");
		return -1;
	}
	else
	{
		printf("Create Thread mediaRecvPthread successfully\n");
		//WaitForSingleObject(mediaRecvHandle, INFINITE);
		WaitForSingleObject(mediaRecvHandle, 50);
	}
	return 0;
	//WaitForMultipleObjects(THREAD_NUM, (const HANDLE *)mediaRecvHandle, TRUE, INFINITE);
}

//static void filesearch(char const* path)
//{
//    struct _finddata_t filefind;	
//    String curr = String(path) + "\\*.*";
//	char tmp[128] = {0};
//	char video_path[64] = {0};
//    int done = 0, i, handle, j = 0, ret = -1, count = 0;
//	char filename[50][32] = {0};
//    if((handle=_findfirst(curr.c_str(),&filefind))==-1)return;
//    while(!(done=_findnext(handle,&filefind)))
//    {
//        if(!strcmp(filefind.name,".."))continue;
//		if ((_A_SUBDIR==filefind.attrib))
//        {
//			//cout<<filefind.name<<"(dir)"<<endl;
//            curr=String(path) + "\\";
//            filesearch(curr);
//        }
//        else 
//        {
//            //cout<<filefind.name<<endl;
//			if (NULL != strstr(filefind.name, ".avi"))
//			{
//			    memcpy(filename[count], filefind.name, strlen(filefind.name));
//			    //Output("%d:%s\n", count, filename[count]);
//				count++;
//			}
//        }
//    }    
//	if (count > file_count)
//	{
//		for (i = 0; i < count - file_count ; i++)
//		{
//			//Output("%d:%s\n", i, filename[i]);
//			curr=String(path) + "//" + filename[i];
//			ret = remove(curr.c_str());
//			memcpy(tmp, curr.c_str(), curr.length());
//			memcpy(video_path, tmp + 56, 36);
//			//strncat(video_path, ".mp4", 4);
//			//Output("11111111111111the video_path is %s", video_path);
//			//del((const char *)video_path);
//		}
//	}
//
//	_findclose(handle);
//}

int changePath(char *uid, char *path)
{
	char comNum[2] = {0};
	char banNum[4] = {0};
	char houNum[4] = {0};

	memcpy(comNum, uid, 2);
	memcpy(banNum, uid + 2, 4);
	memcpy(houNum, uid + 6, 4);

	strcat(path, "./apache-tomcat-7.0.37//webapps//FamilyGuardian//video//");
	strncat(path, comNum, 2);
	strcat(path, "//");
	strncat(path, banNum, 4);
	strcat(path, "//");
	strncat(path, houNum, 4);

	return 0;
}

int createMediaPath(char *uid, char *path)
{
	char tmpPath[128] = {0};

	changePath(uid, path);
	memcpy(tmpPath, path, sizeof(tmpPath));
	CheckDirectory(tmpPath);

	return 0;
}

int mediaServiceStart(MEDIAINFO *mediaInfo, char *filePath)
{
	int mediaRecvPort = 0;
	MEDIAPATH mediaPath = {0};
	char nowTime[32] = {0};
	char path[128] = {0};

	getNowTime(nowTime);
	//strncat(filePath, nowTime, strlen(nowTime));
	//memcpy(mediaPath.filePath, filePath, strlen(filePath) + 1);
	if (!strncmp(mediaInfo->audio, "audio", 5))
	{
		mediaRecvPort = getMediaPort();
		memset(mediaInfo->audio, 0, sizeof(mediaInfo->audio));
		itoa(mediaRecvPort, mediaInfo->audio, 10);
		memcpy(mediaPath.mediaValue, mediaInfo->audio, sizeof(mediaInfo->audio));
		memset(path, 0, sizeof(path));
		changeStr(filePath, "00", nowTime, ".wav", path);
		memcpy(mediaPath.filePath, path, strlen(path) + 1);
		mediaRecvPthreadInit(&mediaPath);
		printf("mediaRecvPort is %d, mediaInfo->audio is %s.\n", mediaRecvPort, mediaInfo->audio);
	}

	if (!strncmp(mediaInfo->video0, "video0", 6))
	{
		mediaRecvPort = getMediaPort();
		memset(mediaInfo->video0, 0, sizeof(mediaInfo->video0));
		itoa(mediaRecvPort, mediaInfo->video0, 10);
		memcpy(mediaPath.mediaValue, mediaInfo->video0, sizeof(mediaInfo->video0));
		memset(path, 0, sizeof(path));
		changeStr(filePath, "00", nowTime, ".dat", path);
		memcpy(mediaPath.filePath, path, strlen(path) + 1);
		mediaRecvPthreadInit(&mediaPath);

		printf("mediaRecvPort is %d, mediaInfo->video0 is %s.\n", mediaRecvPort, mediaInfo->video0);
	}

	if (!strncmp(mediaInfo->video1, "video1", 6))
	{
		mediaRecvPort = getMediaPort();
		memset(mediaInfo->video1, 0, sizeof(mediaInfo->video1));
		itoa(mediaRecvPort, mediaInfo->video1, 10);
		memcpy(mediaPath.mediaValue, mediaInfo->video1, sizeof(mediaInfo->video1));
		memset(path, 0, sizeof(path));
		changeStr(filePath, "01", nowTime, ".dat", path);
		memcpy(mediaPath.filePath, path, strlen(path) + 1);
		mediaRecvPthreadInit(&mediaPath);
		printf("mediaRecvPort is %d, mediaInfo->video1 is %s.\n", mediaRecvPort, mediaInfo->video1);
	}

	if (!strncmp(mediaInfo->video2, "video2", 6))
	{
		mediaRecvPort = getMediaPort();
		memset(mediaInfo->video2, 0, sizeof(mediaInfo->video1));
		itoa(mediaRecvPort, mediaInfo->video2, 10);
		memcpy(mediaPath.mediaValue, mediaInfo->video2, sizeof(mediaInfo->video2));
		memset(path, 0, sizeof(path));
		changeStr(filePath, "02", nowTime, ".dat", path);
		memcpy(mediaPath.filePath, path, strlen(path) + 1);
		mediaRecvPthreadInit(&mediaPath);
		printf("mediaRecvPort is %d, mediaInfo->video2 is %s.\n", mediaRecvPort, mediaInfo->video2);
	}

	if (!strncmp(mediaInfo->video3, "video3", 6))
	{
		mediaRecvPort = getMediaPort();
		memset(mediaInfo->video3, 0, sizeof(mediaInfo->video3));
		itoa(mediaRecvPort, mediaInfo->video3, 10);
		memcpy(mediaPath.mediaValue, mediaInfo->video3, sizeof(mediaInfo->video3));
		memset(path, 0, sizeof(path));
		changeStr(filePath, "03", nowTime, ".dat", path);
		memcpy(mediaPath.filePath, path, strlen(path) + 1);
		mediaRecvPthreadInit(&mediaPath);
		printf("mediaRecvPort is %d, mediaInfo->video3 is %s.\n", mediaRecvPort, mediaInfo->video3);
	}
    printf("uid is %s.\n", mediaInfo->uid);
	printf("audio is %s.\n", mediaInfo->audio);
	printf("video0 is %s.\n", mediaInfo->video0);
	printf("video1 is %s.\n", mediaInfo->video1);
	printf("video2 is %s.\n", mediaInfo->video2);
	printf("video3 is %s.\n", mediaInfo->video3);
	return 0;
}

DWORD WINAPI mediaServicePthread(LPVOID pM)
{
	BOOL bDontLinger = FALSE;
	BOOL bReuseaddr = TRUE;
	//int nNetTimeout = TIME; //阻塞
	int recvAddrLen = 0;
	char localip[20];
	int recvLength = -1;
	int sendLength = -1;
	int recvAddrSize = sizeof(recvFromAddr);
	char recvBuffer[BUFFER_SIZE] = {0};
	char filePath[128] = {0};
	MEDIAINFO mediaInfo = {0};
	//USERINFO *userInfoHead = NULL;
	//unsigned long ul = 1;
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);
	
	recvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	//if (SOCKET_ERROR == ioctlsocket(recvSocket, FIONBIO, (unsigned long *)&ul))  //设置成非阻塞函数
	//{
	//	printf("ioctlsocket fiald\n");
	//	return -1;
	//}

	memset(&recvAddr, 0, sizeof(recvAddr));
	recvAddr.sin_family = AF_INET;
	//recvAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	recvAddr.sin_addr.S_un.S_addr = inet_addr(SERVERIP);
	recvAddr.sin_port = htons(SERVERPORT);
	recvAddrLen = sizeof(recvAddr);

	if (0 != bind(recvSocket, (SOCKADDR *)&recvAddr, recvAddrLen))
	{
		printf("mediaRecvInit Bind filed!\n");
		return -1;
	}

	setsockopt(recvSocket, SOL_SOCKET, SO_DONTLINGER, (const char*)&bDontLinger, sizeof(BOOL));
	setsockopt(recvSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&bReuseaddr, sizeof(BOOL));
	//setsockopt(recvSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&nNetTimeout, sizeof(BOOL));

	mediaServiceStatus = 1;
	
	while (mediaServiceStatus)
	{
	    memset(recvBuffer, 0, sizeof(recvBuffer));
		recvLength = recvfrom(recvSocket, recvBuffer, sizeof(recvBuffer), 0, (SOCKADDR *)&recvFromAddr, &recvAddrSize);

		recvBuffer[recvLength] = ‘\0‘;

		if (strncmp("Media", recvBuffer, 5))
		{
			continue;
		}

		memcpy((unsigned char *)&mediaInfo, recvBuffer, recvLength);
		mediaInfo.address = recvFromAddr;

		//printf("uid is %s.\n", mediaInfo.uid);
		//printf("audio is %s.\n", mediaInfo.audio);
		//printf("video0 is %s.\n", mediaInfo.video0);
		//printf("video1 is %s.\n", mediaInfo.video1);
		//printf("video2 is %s.\n", mediaInfo.video2);
		//printf("video3 is %s.\n", mediaInfo.video3);

		if (0 != createMediaPath(mediaInfo.uid, filePath))
		{
			printf("create media path error\n");
		}
		
		if (0 != mediaServiceStart(&mediaInfo, filePath))
		{
			printf("media service start error\n");
		}

		memcpy(recvBuffer, (unsigned char *)&mediaInfo, sizeof(mediaInfo));

		sendLength = sendto(recvSocket, recvBuffer, sizeof(mediaInfo), 0, (SOCKADDR *)&recvFromAddr, recvAddrSize);
		if (0 > sendLength)
		{
			printf("send mediaInfo error\n");
		}
	}
	closesocket(recvSocket);
	WSACleanup();

	return 0;
}

int mediaServicePthreadInit()
{
	HANDLE mediaServiceHandle = NULL;
	mediaServiceHandle = CreateThread(NULL, NULL, mediaServicePthread, NULL, 0 , NULL);
	if (NULL == mediaServiceHandle)
	{
	    printf("CreatePthread mediaServicePthread error.\n");
		return -1;
	}
	else
	{
		printf("CreatePthread mediaServicePthread successfully.\n");
	}

	return 0;
}

int tempFun()
{
	int ret = -1;
	//ret = mediaRecvPthreadInit();
	ret = mediaServicePthreadInit();
	if (-1 == ret)
	{
		printf("mediaRecvPthreadInit faild\n");
		return -1;
	}
	else
	{
		printf("mediaRecvPthreadInit successfully\n");
	}

	return 0;
}

int main(int argc, char *argv[])
{
	char cmd[10] = {0};
	
	tempFun();
	//Sleep(10000);
	while(1)
	{
		printf("input ‘quit‘ closed.\n");
		scanf("%s", cmd);
		if (!strncmp(cmd, "quit", 4))
		{
			break;
		}
	}
	system("pause");
	return 0;
}
udpMediaService.h

#ifndef UDPMEDIASERVICE_H
#define UDPMEDIASERVICE_H

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <WS2tcpip.h>

#pragma comment(lib, "ws2_32.lib")

#define SERVERIP "192.168.1.77"
#define SERVERPORT 7777
#define TIME 60*1000
#define BUFFER_SIZE 1500
#define THREAD_NUM 10

int mediaServiceStatus;
//int mediaRecvStatus = 0;

typedef struct media_info
{
	char media[6];
	char uid[11];
	char audio[6];
	char video0[7];
	char video1[7];
	char video2[7];
	char video3[7];
	struct sockaddr_in address;
}MEDIAINFO;

typedef struct userList {
	MEDIAINFO mediaInfo;
	struct userList *next;
}USERINFO;

typedef struct mediaValueFilePath
{
	char mediaValue[7];
	char filePath[128];
}MEDIAPATH;

SOCKET recvSocket;
struct sockaddr_in recvAddr;
struct sockaddr_in recvFromAddr, sendToRcevAddr;
SOCKET sendSocket;
struct sockaddr_in sendAddr;
struct sockaddr_in sendToAddr;

int mediaRecvInit();
int mediaSendInit();
int mediaRecv(char *buffer, int len);
int mediaSend(char *buffer, int len);
int mediaRecvEixt(void);
int mediaSendExit(void);

int memoryError(USERINFO *p);
int creatUserList(USERINFO *head);
int findUser(USERINFO *head, char name[10]);
int delUser(USERINFO *head, char name[10]);
int getAllUser(USERINFO  const *head);
int addUser(USERINFO *head, MEDIAINFO data);

int getMediaPort();
int getNowTime(char *nowTime);
int changeStr(const char *str1, const char *str2, const char *str3, const char *str4, char *outstr);

int mediaRecvPthreadInit(MEDIAPATH *mediaValue);
DWORD WINAPI mediaRecvPthread(LPVOID pM);

//bool FindOrCreateDirectory( const char* pszPath );
//bool CheckDirectory( char* pszPath );

int createMediaPath(char *uid, char *path);

int mediaServiceStart(MEDIAINFO *mediaInfo, char *filePath);
DWORD WINAPI mediaServicePthread(LPVOID pM);
int mediaServicePthreadInit();

#endif