/*****************************************************************************
 *                                                                           *
 * DH_MISC.C                                                                 *
 *                                                                           *
 * Freely redistributable and modifiable.  Use at your own risk.             *
 *                                                                           *
 * Copyright 1994 The Downhill Project                                       *
 *                                                                           *
 *****************************************************************************/


/* Include stuff *************************************************************/
#include "INCLUDE/DH.H"
#include <stdio.h>
#include <sys/utsname.h>



/* Function stuff ************************************************************/

/* Sleep =================================================================== */
unsigned int sleep(unsigned int sleep_Duration)
{
	unsigned long sleep_Time = sleep_Duration*1000;

	/* While there's time left, keep sleeping */
	while (sleep_Time > 0)
	{
		/* Return if we were interrupted */
		if (downhill_Signal_IsInterrupted())
		{
			return ((unsigned int)(sleep_Time/1000))+1;
		}

		/* Sleep it off */
		Sleep(DOWNHILL_SLEEP_TIME);
		sleep_Time -= DOWNHILL_SLEEP_TIME;
	}

	return 0;
}

/* Pause until a signal ==================================================== */
int pause(void)
{
	/* Wait for a signal */
	for (;;)
	{
		/* And return if we were interrupted */
		if (sleep(1) > 0)
		{
			errno = EINTR;
			return -1;
		}
	}
}

/* Return version information ============================================== */
int uname(struct utsname* system_Info)
{
	DWORD version_Info = GetVersion();
	WORD  version_Number = LOWORD(version_Info);

	/* Get the OS name */
	if (HIBYTE(HIWORD(version_Info))&0x80)
	{
		strcpy(system_Info->sysname,"Windows");
	}
	else
	{
		strcpy(system_Info->sysname,"WindowsNT");
	}

	/* Get the nodename */
	if (gethostname(system_Info->nodename,MAXHOSTNAMELEN) == SOCKET_ERROR)
	{
		strcpy(system_Info->nodename,"localhost");
        }

	/* Get the version and release number */
	sprintf(system_Info->version,"%d",LOBYTE(version_Number));
	sprintf(system_Info->release,"%d",HIBYTE(version_Number));

	/* Get the machine type */
	strcpy(system_Info->machine,_DOWNHILL_MACHINE_TYPE);

	/* Fake an ID number */
	{
		unsigned int id_Number = 0;
		unsigned int id_Index;
		char         id_Temp[sizeof(system_Info->nodename)+
		              sizeof(system_Info->machine)+1];

		/* This is all completely arbitrary but reproducable */
		strcpy(id_Temp,system_Info->nodename);
		strcat(id_Temp,system_Info->machine);
		for (id_Index = 0;id_Index < strlen(id_Temp);id_Index++)
		{
			id_Number += id_Temp[id_Index]*id_Index;
		}
		sprintf(system_Info->idnumber,"%lx",id_Number);
	}

	return 0;
}


/* Get command-line flags ================================================== */
#if (_DOWNHILL_POSIX_SOURCE == -1)
/* This was originally the public domain AT&T getopt().  Mine's prettier, if
   you ask _me_. */

/* Global stuff **************************************************************/
int   opterr = 1;
int   optind = 1;
int   optopt;
char* optarg;

int getopt(int arg_Count,char* arg_Value[],char flag_List[])
{
	static int opt_Position = 1;
	char*      opt_Flag;

	/* If we're at the end of the list, return */
	if (opt_Position == 1)
	{
		if (optind >= arg_Count)
		{
			return EOF;
		}
		else if (((arg_Value[optind][0] != '-')
#if defined(_DOWNHILL_GETOPT_SWITCH)
		 && (arg_Value[optind][0] != _DOWNHILL_GETOPT_SWITCH)
#endif
		 ) || (arg_Value[optind][1] == '\0'))
		{
			return EOF;
		}
		else if (!strcmp(arg_Value[optind],"--"))
		{
			optind++;
			return EOF;
		}
	}

	/* Get this flag */
	optopt = arg_Value[optind][opt_Position];
	opt_Flag = strchr(flag_List,optopt);
	if ((optopt == ':') || (opt_Flag == NULL))
	{
		fprintf(stderr,"%s: illegal option -- %c\n",
		 arg_Value[0],optopt);
		opt_Position++;
		if (arg_Value[optind][opt_Position] == '\0')
		{
			optind++;
			opt_Position = 1;
		}
		return '?';
	}

	/* Does this flag take an argument? */
	opt_Flag++;
	if (*opt_Flag == ':')
	{
		opt_Position++;
		if (arg_Value[optind][opt_Position] != '\0')
		{
			opt_Position++;
			optarg = &(arg_Value[optind][opt_Position]);
		}
		else if (optind+1 >= arg_Count)
		{
			fprintf(stderr,
			 "%s: option requires an argument -- %c\n",
			 arg_Value[0],optopt);
			opt_Position = 1;
			return '?';
		}
		else
		{
			optind++;
			optarg = arg_Value[optind];
		}
		optind++;
		opt_Position = 1;
	}
	else
	{
		opt_Position++;
		if (arg_Value[optind][opt_Position] == '\0')
		{
			opt_Position = 1;
			optind++;
		}
		optarg = NULL;
	}

	/* Return the character */
	return optopt;
}
#endif

// kms
#include <io.h>
#include <fcntl.h>

int pipe(int p[])
{
int po[2],ret;

 ret=_pipe( po, 4096 , O_BINARY | O_NOINHERIT);
 if( ret <0 ) return ret;
 p[0]= _dup(po[0]); if( p[0] <0 ) return ret;
 p[1]= _dup(po[1]); if( p[1] <0 ) return ret;
close(po[0]);close(po[1]);

return 0;
}