Mutex driving me insane.....

void count_thread(int iterations)
{
     int i, x;
     for(i=0; i<iterations; i++)
     {
         // wait until the mutex is free before incrementing
         WaitForSingleObject(mutex, INFINITE);  
          x = count;
          x++;
          count = x;
          // free the mutex for other threads
          ReleaseMutex(mutex);
       }
}

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

void *thread_function(void *arg);
pthread_mutex_t work_mutex; /* protect work_area and time_to_exit */
#define WORK_SIZE 1024
char work_area[WORK_SIZE];
int time_to_exit = 0;

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    res = pthread_mutex_init(&work_mutex, NULL);
    if (res != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    pthread_mutex_lock(&work_mutex);
    printf("Input some text. Enter 'end' to finish\n");
    while(!time_to_exit) {
        fgets(work_area, WORK_SIZE, stdin);
        pthread_mutex_unlock(&work_mutex);
        while(1) {
            pthread_mutex_lock(&work_mutex);
            if (work_area[0] != '\0') {
                pthread_mutex_unlock(&work_mutex);
                sleep(1);
            }
            else {
                break;
            }
        }
    }
    pthread_mutex_unlock(&work_mutex);
    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    pthread_mutex_destroy(&work_mutex);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    sleep(1);
    pthread_mutex_lock(&work_mutex);
    while(strncmp("end", work_area, 3) != 0) {
        printf("You input %d characters\n", strlen(work_area) -1);
        work_area[0] = '\0';
        pthread_mutex_unlock(&work_mutex);
        sleep(1);
        pthread_mutex_lock(&work_mutex);
        while (work_area[0] == '\0' ) {
            pthread_mutex_unlock(&work_mutex);
            sleep(1);
            pthread_mutex_lock(&work_mutex);
        }
    }
    time_to_exit = 1;
    work_area[0] = '\0';
    pthread_mutex_unlock(&work_mutex);
    pthread_exit(0);
}

void count_thread(int iterations)
{
     int i, x;
     for(i=0; i<iterations; i++)
     {
         // wait until the mutex is free before incrementing
         WaitForSingleObject(mutex, INFINITE);  
          x = count;
          x++;
          count = x;
          // free the mutex for other threads
          ReleaseMutex(mutex);
       }
}

WaitForSingleObject(mutex, INFINITE);  

Char *buf[100]
WaitForSingleObject(buf, INFINITE);  

// wait until the mutex is free before reading/writing
WaitForSingleObject(mutex, INFINITE);  
//perform read or write
// free the mutex for other threads
ReleaseMutex(mutex);

HANDLE    mutex=NULL;

mutex = CreateMutex(NULL,  //no security
               FALSE, //no owner
                szMutexName); // the handles name

#include <windows.h>
#include <iostream.h> 

#define MAX_THREADS 2
char buf[100]="empty";

HANDLE hThreads[MAX_THREADS];	// An array of thread handles.

DWORD  id[MAX_THREADS];	// An array of thread id's.


int c = 1;
int j = 1;

DWORD WINAPI ReadThread(LPVOID n) {

	while(j<10)
	{

cout<<"thread1 ";	
cout<<buf;
cout<<"\n";

}
	return (DWORD)n;
}

DWORD WINAPI NetThread(LPVOID n) {
     while(c<10)
{
int PORT=3550;     	      	
int MAXDATASIZE=1000;      	    



struct       sockaddr_in server;   
             SOCKADDR_IN addr,			
             remote_addr;		
int iRemoteAddrLen;	




WSADATA  wsdata;
SOCKET   sock;
DWORD    wsock;



	WSAStartup(0x0202,&wsdata);	
  if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)      	
   {
        MessageBox(0,"call socket failed","Error",0);
         return -1;
   }

		addr.sin_family = AF_INET;
		addr.sin_port = htons(PORT);
		addr.sin_addr.s_addr = INADDR_ANY;       
		if(bind(sock, (struct sockaddr *) &addr, sizeof(addr)) == SOCKET_ERROR)
   {
 MessageBox(0,"Bind Socket Failed","Error",0);
         return -1;
   }

	
	iRemoteAddrLen = sizeof(remote_addr);
if ((recvfrom(sock, buf, MAXDATASIZE, 0, (struct sockaddr *) &remote_addr, &iRemoteAddrLen))== -1)
	
	 {
           MessageBox(0," Recv Socket Error","Error",0);
         return -1;
   }


closesocket(sock);     
 WSACleanup();
 
	
}
return (DWORD)n;
}


int main(int argc, char* argv[]) {

	int intParameter = 100;
	char *string = "What's up?";

	
	hThreads[0] = CreateThread(NULL,0,ReadThread,(LPVOID)intParameter,NULL,&id[0]);
	hThreads[1] = CreateThread(NULL,0,NetThread,(LPVOID)string,NULL,&id[1]);

		WaitForMultipleObjects(MAX_THREADS,hThreads,TRUE,INFINITE);

		for(int i = 0; i < MAX_THREADS; i++) {
		CloseHandle(hThreads[i]);
	}	

	
	return 0;
}