mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 22:28:36 +00:00
340 lines
5.8 KiB
C
340 lines
5.8 KiB
C
#include "precomp.h"
|
|
|
|
#include <wincon.h>
|
|
|
|
#define MAX_ASCII 100
|
|
|
|
int checkRecv(SOCKET s);
|
|
|
|
int checkRecv(SOCKET s)
|
|
{
|
|
int testVal;
|
|
fd_set sSet;
|
|
struct timeval timeout;
|
|
timeout.tv_sec = 60;
|
|
|
|
FD_ZERO(&sSet);
|
|
|
|
FD_SET(s, &sSet);
|
|
|
|
testVal = select(0, &sSet, NULL, NULL, &timeout);
|
|
|
|
if (testVal == SOCKET_ERROR)
|
|
fprintf(stderr, "Socket Error");
|
|
|
|
return testVal;
|
|
}
|
|
|
|
void blkfree(char **av0)
|
|
{
|
|
register char **av = av0;
|
|
|
|
while (*av)
|
|
free(*av++);
|
|
}
|
|
|
|
char **glob(const char *v)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int sleep(int time)
|
|
{
|
|
return time;
|
|
}
|
|
|
|
int herror(char *string)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
int gettimeofday(struct timeval *timenow,
|
|
struct timezone *zone)
|
|
{
|
|
time_t t;
|
|
|
|
t = clock();
|
|
|
|
timenow->tv_usec = t;
|
|
timenow->tv_sec = t / CLK_TCK;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int fgetcSocket(int s)
|
|
{
|
|
int c;
|
|
char buffer[10];
|
|
|
|
// checkRecv(s);
|
|
|
|
c = recv(s, buffer, 1, 0);
|
|
|
|
#ifdef DEBUG_IN
|
|
printf("%c", buffer[0]);
|
|
#endif
|
|
|
|
if (c == INVALID_SOCKET)
|
|
return c;
|
|
|
|
if (c == 0)
|
|
return EOF;
|
|
|
|
return buffer[0];
|
|
}
|
|
|
|
#else
|
|
|
|
int fgetcSocket(int s)
|
|
{
|
|
static int index = 0;
|
|
static int total = 0;
|
|
static char buffer[4096];
|
|
|
|
if (index == total)
|
|
{
|
|
index = 0;
|
|
total = recv(s, buffer, sizeof(buffer), 0);
|
|
|
|
if (total == SOCKET_ERROR)
|
|
{
|
|
total = 0;
|
|
return ERROR;
|
|
}
|
|
|
|
if (total == 0)
|
|
return EOF;
|
|
}
|
|
return buffer[index++];
|
|
}
|
|
|
|
#endif
|
|
|
|
const char *fprintfSocket(int s, const char *format, ...)
|
|
{
|
|
va_list argptr;
|
|
char buffer[10009];
|
|
|
|
va_start(argptr, format);
|
|
vsprintf(buffer, format, argptr);
|
|
va_end(argptr);
|
|
|
|
send(s, buffer, strlen(buffer), 0);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const char *fputsSocket(const char *format, int s)
|
|
{
|
|
send(s, format, strlen(format), 0);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int fputcSocket(int s, char putChar)
|
|
{
|
|
char buffer[2];
|
|
|
|
buffer[0] = putChar;
|
|
buffer[1] = '\0';
|
|
|
|
if(SOCKET_ERROR==send(s, buffer, 1, 0)) {
|
|
int iret=WSAGetLastError ();
|
|
fprintf(stdout,"fputcSocket: %d\n",iret);
|
|
return 0;
|
|
}
|
|
else {
|
|
return putChar;
|
|
}
|
|
}
|
|
int fputSocket(int s, char *buffer, int len)
|
|
{
|
|
int iret;
|
|
while(len) {
|
|
if(SOCKET_ERROR==(iret=send(s, buffer, len, 0)))
|
|
{
|
|
iret=WSAGetLastError ();
|
|
fprintf(stdout,"fputcSocket: %d\n",iret);
|
|
return 0;
|
|
}
|
|
else {
|
|
return len-=iret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char *fgetsSocket(int s, char *string)
|
|
{
|
|
char buffer[2] = {0};
|
|
int i, count;
|
|
|
|
for (i = 0, count = 1; count != 0 && buffer[0] != '\n'; i++)
|
|
{
|
|
checkRecv(s);
|
|
|
|
count = recv(s, buffer, 1, 0);
|
|
|
|
if (count == SOCKET_ERROR)
|
|
{
|
|
printf("Error in fgetssocket");
|
|
return NULL;
|
|
}
|
|
|
|
if (count == 1)
|
|
{
|
|
string[i] = buffer[0];
|
|
|
|
if (i == MAX_ASCII - 3)
|
|
{
|
|
count = 0;
|
|
string[++i] = '\n';
|
|
string[++i] = '\0';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (i == 0)
|
|
return NULL;
|
|
else
|
|
{
|
|
string[i] = '\n';
|
|
string[i + 1] = '\0'; // This is risky
|
|
return string;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
string[i] = '\0';
|
|
|
|
#ifdef DEBUG_IN
|
|
printf("%s", string);
|
|
#endif
|
|
return string;
|
|
}
|
|
|
|
|
|
#if 0
|
|
char *getpass(const char *prompt)
|
|
{
|
|
static char string[64];
|
|
|
|
printf("%s", prompt);
|
|
|
|
gets(string);
|
|
|
|
return string;
|
|
}
|
|
#endif
|
|
char *getpass (const char * prompt)
|
|
{
|
|
static char input[256];
|
|
HANDLE in;
|
|
HANDLE err;
|
|
DWORD count;
|
|
|
|
in = GetStdHandle (STD_INPUT_HANDLE);
|
|
err = GetStdHandle (STD_ERROR_HANDLE);
|
|
|
|
if (in == INVALID_HANDLE_VALUE || err == INVALID_HANDLE_VALUE)
|
|
return NULL;
|
|
|
|
if (WriteFile (err, prompt, strlen (prompt), &count, NULL))
|
|
{
|
|
int istty = (GetFileType (in) == FILE_TYPE_CHAR);
|
|
DWORD old_flags;
|
|
int rc;
|
|
|
|
if (istty)
|
|
{
|
|
if (GetConsoleMode (in, &old_flags))
|
|
SetConsoleMode (in, ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
|
|
else
|
|
istty = 0;
|
|
}
|
|
/* Need to read line one byte at time to avoid blocking, if not a
|
|
tty, so always do it this way. */
|
|
count = 0;
|
|
while (1)
|
|
{
|
|
DWORD dummy;
|
|
char one_char;
|
|
|
|
rc = ReadFile (in, &one_char, 1, &dummy, NULL);
|
|
if (rc == 0)
|
|
break;
|
|
if (one_char == '\r')
|
|
{
|
|
/* CR is always followed by LF if reading from tty. */
|
|
if (istty)
|
|
continue;
|
|
else
|
|
break;
|
|
}
|
|
if (one_char == '\n')
|
|
break;
|
|
/* Silently truncate password string if overly long. */
|
|
if (count < sizeof (input) - 1)
|
|
input[count++] = one_char;
|
|
}
|
|
input[count] = '\0';
|
|
|
|
WriteFile (err, "\r\n", 2, &count, NULL);
|
|
if (istty)
|
|
SetConsoleMode (in, old_flags);
|
|
if (rc)
|
|
return input;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#if 0
|
|
// Stubbed out here. Should be changed in Source code...
|
|
int access(const char *filename, int accessmethod)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef __GNUC__
|
|
#define EPOCHFILETIME (116444736000000000i64)
|
|
#else
|
|
#define EPOCHFILETIME (116444736000000000LL)
|
|
#endif
|
|
|
|
int gettimeofday(struct timeval *tv, struct timezone *tz)
|
|
{
|
|
FILETIME ft;
|
|
LARGE_INTEGER li;
|
|
__int64 t;
|
|
static int tzflag;
|
|
|
|
if (tv)
|
|
{
|
|
GetSystemTimeAsFileTime(&ft);
|
|
li.LowPart = ft.dwLowDateTime;
|
|
li.HighPart = ft.dwHighDateTime;
|
|
t = li.QuadPart; /* In 100-nanosecond intervals */
|
|
t -= EPOCHFILETIME; /* Offset to the Epoch time */
|
|
t /= 10; /* In microseconds */
|
|
tv->tv_sec = (long)(t / 1000000);
|
|
tv->tv_usec = (long)(t % 1000000);
|
|
}
|
|
|
|
if (tz)
|
|
{
|
|
if (!tzflag)
|
|
{
|
|
_tzset();
|
|
tzflag++;
|
|
}
|
|
tz->tz_minuteswest = _timezone / 60;
|
|
tz->tz_dsttime = _daylight;
|
|
}
|
|
|
|
return 0;
|
|
}
|