mirror of https://github.com/0intro/conterm
471 lines
8.0 KiB
C
471 lines
8.0 KiB
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
|
|
win_hasunicode(void)
|
|
{
|
|
OSVERSIONINFOA osinfo;
|
|
int r;
|
|
|
|
osinfo.dwOSVersionInfoSize = sizeof(osinfo);
|
|
if(!GetVersionExA(&osinfo))
|
|
panic("GetVersionEx failed");
|
|
switch(osinfo.dwPlatformId) {
|
|
default:
|
|
panic("unknown PlatformId");
|
|
case VER_PLATFORM_WIN32s:
|
|
panic("Win32s not supported");
|
|
case VER_PLATFORM_WIN32_WINDOWS:
|
|
r = 0;
|
|
break;
|
|
case VER_PLATFORM_WIN32_NT:
|
|
r = 1;
|
|
break;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
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;
|
|
Rune *warg;
|
|
|
|
if(0 && win_hasunicode()){
|
|
warg = GetCommandLineW();
|
|
n = (wstrlen(warg)+1)*UTFmax;
|
|
arg = malloc(n);
|
|
wstrtoutf(arg, warg, n);
|
|
}else
|
|
arg = GetCommandLineA();
|
|
|
|
/* 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)
|
|
{
|
|
Rune *action, *arg, *cmd, *p;
|
|
static Rune Lopen[] = { 'o', 'p', 'e', 'n', 0 };
|
|
|
|
cmd = runesmprint("%.*s", n, a);
|
|
if(cmd == nil)
|
|
error("out of memory");
|
|
if(cmd[runestrlen(cmd)-1] == '\n')
|
|
cmd[runestrlen(cmd)] = 0;
|
|
p = runestrchr(cmd, ' ');
|
|
if(p){
|
|
action = cmd;
|
|
*p++ = 0;
|
|
arg = p;
|
|
}else{
|
|
action = Lopen;
|
|
arg = cmd;
|
|
}
|
|
ShellExecute(0, 0, action, arg, 0, SW_SHOWNORMAL);
|
|
return n;
|
|
}
|