ref: a97255112d90b1c776d610ac360a857af87556f3
dir: /kern/win32.c/
#include <windows.h>
#include "u.h"
#include "lib.h"
#include "dat.h"
#include "fns.h"
#include <libsec.h>
typedef struct Oproc Oproc;
struct Oproc {
int tid;
HANDLE *sema;
};
static int tlsx = TLS_OUT_OF_INDEXES;
char *argv0;
Proc*
_getproc(void)
{
if(tlsx == TLS_OUT_OF_INDEXES)
return nil;
return TlsGetValue(tlsx);
}
void
_setproc(Proc *p)
{
if(tlsx == TLS_OUT_OF_INDEXES){
tlsx = TlsAlloc();
if(tlsx == TLS_OUT_OF_INDEXES)
panic("out of indexes");
}
TlsSetValue(tlsx, p);
}
void
oserror(void)
{
oserrstr();
nexterror();
}
void
osinit(void)
{
Oproc *t;
static Proc firstprocCTstore;
_setproc(&firstprocCTstore);
t = (Oproc*)firstprocCTstore.oproc;
assert(t != 0);
t->tid = GetCurrentThreadId();
t->sema = CreateSemaphore(0, 0, 1000, 0);
if(t->sema == 0) {
oserror();
panic("could not create semaphore: %r");
}
}
void
osnewproc(Proc *p)
{
Oproc *op;
op = (Oproc*)p->oproc;
op->sema = CreateSemaphore(0, 0, 1000, 0);
if (op->sema == 0) {
oserror();
panic("could not create semaphore: %r");
}
}
void
osmsleep(int ms)
{
Sleep((DWORD) ms);
}
void
osyield(void)
{
Sleep(0);
}
static DWORD WINAPI tramp(LPVOID vp);
void
osproc(Proc *p)
{
DWORD tid;
if(CreateThread(0, 0, tramp, p, 0, &tid) == 0) {
oserror();
panic("osproc: %r");
}
Sleep(0);
}
static DWORD WINAPI
tramp(LPVOID vp)
{
Proc *p = (Proc *) vp;
Oproc *op = (Oproc*) p->oproc;
_setproc(p);
op->tid = GetCurrentThreadId();
op->sema = CreateSemaphore(0, 0, 1000, 0);
if(op->sema == 0) {
oserror();
panic("could not create semaphore: %r");
}
(*p->fn)(p->arg);
ExitThread(0);
return 0;
}
void
procsleep(void)
{
Proc *p;
Oproc *op;
p = up;
op = (Oproc*)p->oproc;
WaitForSingleObject(op->sema, INFINITE);}
void
procwakeup(Proc *p)
{
Oproc *op;
op = (Oproc*)p->oproc;
ReleaseSemaphore(op->sema, 1, 0);
}
void
random20(uchar *p)
{
LARGE_INTEGER ti;
int i, j;
FILETIME ft;
DigestState ds;
vlong tsc;
GetSystemTimeAsFileTime(&ft);
memset(&ds, 0, sizeof ds);
sha1((uchar*)&ft, sizeof(ft), 0, &ds);
for(i=0; i<50; i++) {
for(j=0; j<10; j++) {
QueryPerformanceCounter(&ti);
sha1((uchar*)&ti, sizeof(ti), 0, &ds);
tsc = GetTickCount();
sha1((uchar*)&tsc, sizeof(tsc), 0, &ds);
}
Sleep(10);
}
sha1(0, 0, p, &ds);
}
void
randominit(void)
{
}
ulong
randomread(void *v, ulong n)
{
int i;
uchar p[20];
for(i=0; i<n; i+=20){
random20(p);
if(i+20 <= n)
memmove((char*)v+i, p, 20);
else
memmove((char*)v+i, p, n-i);
}
return n;
}
long
seconds(void)
{
return time(0);
}
ulong
ticks(void)
{
return GetTickCount();
}
#if 0
uvlong
fastticks(uvlong *v)
{
uvlong n;
n = GetTickCount() * 1000 * 1000;
if(v)
*v = n;
return n;
}
#endif
extern int main(int, char*[]);
int
wstrutflen(Rune *s)
{
int n;
for(n=0; *s; n+=runelen(*s),s++)
;
return n;
}
int
wstrtoutf(char *s, Rune *t, int n)
{
int i;
char *s0;
s0 = s;
if(n <= 0)
return wstrutflen(t)+1;
while(*t) {
if(n < UTFmax+1 && n < runelen(*t)+1) {
*s = 0;
return s-s0+wstrutflen(t)+1;
}
i = runetochar(s, t);
s += i;
n -= i;
t++;
}
*s = 0;
return s-s0;
}
int
wstrlen(Rune *s)
{
int n;
for(n=0; *s; s++,n++)
;
return n;
}
static int args(char *argv[], int n, char *p);
int APIENTRY
WinMain(HINSTANCE x, HINSTANCE y, LPSTR z, int w)
{
int argc, n;
char *arg, *p, **argv;
wchar_t *warg;
warg = GetCommandLineW();
n = wcslen(warg)*UTFmax+1;
arg = malloc(n);
WideCharToMultiByte(CP_UTF8,0,warg,-1,arg,n,0,0);
/* conservative guess at the number of args */
for(argc=4,p=arg; *p; p++)
if(*p == ' ' || *p == '\t')
argc++;
argv = malloc(argc*sizeof(char*));
argc = args(argv, argc, arg);
mymain(argc, argv);
ExitThread(0);
return 0;
}
/*
* Break the command line into arguments
* The rules for this are not documented but appear to be the following
* according to the source for the microsoft C library.
* Words are seperated by space or tab
* Words containing a space or tab can be quoted using "
* 2N backslashes + " ==> N backslashes and end quote
* 2N+1 backslashes + " ==> N backslashes + literal "
* N backslashes not followed by " ==> N backslashes
*/
static int
args(char *argv[], int n, char *p)
{
char *p2;
int i, j, quote, nbs;
for(i=0; *p && i<n-1; i++) {
while(*p == ' ' || *p == '\t')
p++;
quote = 0;
argv[i] = p2 = p;
for(;*p; p++) {
if(!quote && (*p == ' ' || *p == '\t'))
break;
for(nbs=0; *p == '\\'; p++,nbs++)
;
if(*p == '"') {
for(j=0; j<(nbs>>1); j++)
*p2++ = '\\';
if(nbs&1)
*p2++ = *p;
else
quote = !quote;
} else {
for(j=0; j<nbs; j++)
*p2++ = '\\';
*p2++ = *p;
}
}
/* move p up one to avoid pointing to null at end of p2 */
if(*p)
p++;
*p2 = 0;
}
argv[i] = 0;
return i;
}
/*
* Windows socket error messages
* There must be a way to get these strings out of the library.
* This table is derived from the MSDN online help.
*/
static struct {
int e;
char *s;
} tab[] = {
{ 10004, "interrupted function call" },
{ 10013, "permission denied" },
{ 10014, "bad address" },
{ 10022, "invalid argument" },
{ 10024, "too many open files" },
{ 10035, "resource temporarily unavailable" },
{ 10036, "operation now in progress" },
{ 10037, "operation already in progress" },
{ 10038, "socket operation on nonsocket" },
{ 10039, "destination address required" },
{ 10040, "message too long" },
{ 10041, "protocol wrong type for socket" },
{ 10042, "bad protocol option" },
{ 10043, "protocol not supported" },
{ 10044, "socket type not supported" },
{ 10045, "operation not supported" },
{ 10046, "protocol family not supported" },
{ 10047, "address family not supported by protocol family" },
{ 10048, "address already in use" },
{ 10049, "cannot assign requested address" },
{ 10050, "network is down" },
{ 10051, "network is unreachable" },
{ 10052, "network dropped connection on reset" },
{ 10053, "software caused connection abort" },
{ 10054, "connection reset by peer" },
{ 10055, "no buffer space available" },
{ 10056, "socket is already connected" },
{ 10057, "socket is not connected" },
{ 10058, "cannot send after socket shutdown" },
{ 10060, "connection timed out" },
{ 10061, "connection refused" },
{ 10064, "host is down" },
{ 10065, "no route to host" },
{ 10067, "too many processes" },
{ 10091, "network subsystem is unavailable" },
{ 10092, "winsock.dll version out of range" },
{ 10093, "wsastartup not called" },
{ 10101, "graceful shutdown in progress" },
{ 10109, "class type not found" },
{ 11001, "host name not found" },
{ 11002, "host not found (non-authoritative)" },
{ 11003, "nonrecoverable error" },
{ 11004, "valid name, but no data record of requested type" },
};
void
osrerrstr(char *buf, uint nbuf)
{
char *p, *q;
int e, i, r;
e = GetLastError();
r = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
0, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
buf, nbuf, 0);
if(r == 0){
for(i=0; i<nelem(tab); i++)
if(tab[i].e == e){
strecpy(buf, buf+nbuf, tab[i].s);
break;
}
if(i==nelem(tab))
snprint(buf, nbuf, "windows error %d", e);
}
for(p=q=buf; *p; p++) {
if(*p == '\r')
continue;
if(*p == '\n')
*q++ = ' ';
else
*q++ = *p;
}
*q = '\0';
}
void
oserrstr(void)
{
osrerrstr(up->errstr, ERRMAX);
}
long
showfilewrite(char *a, int n)
{
wchar_t *action, *arg, *cmd, *p;
int m;
cmd = malloc((n+1)*sizeof(wchar_t));
if(cmd == nil)
error("out of memory");
m = MultiByteToWideChar(CP_UTF8,0,a,n,cmd,n);
while(m > 0 && cmd[m-1] == '\n')
m--;
cmd[m] = 0;
p = wcschr(cmd, ' ');
if(p){
action = cmd;
*p++ = 0;
arg = p;
}else{
action = L"open";
arg = cmd;
}
ShellExecuteW(0, action, arg, 0, 0, SW_SHOWNORMAL);
free(cmd);
return n;
}