short frdmsg(char *str)
{
char *smax;
char *s = str;
smax = s + MAXPACK - 1;
for (;;) {
if (sread(s, 1, M_fPacketTimeout) <= 0)
{
printmsg(0,"frdmsg: timeout reading message");
*s++ = '\0';
goto msgerr;
}
if (*s == '\r')
break;
if (*s < ' ')
continue;
if (s++ >= smax)
{
printmsg(0,"frdmsg: buffer overflow");
*--s = '\0';
goto msgerr;
} /* if (s++ >= smax) */
}
*s = '\0';
return DCP_OK;
msgerr:
printmsg(0,"frdmsg: Message received \"%s\"", str);
return DCP_FAILED;
} /* frdmsg */
static void imStatus(IMFILE *imf)
{
#ifdef UDEBUG
if (imf->buffer != NULL)
printmsg(18,"imStatus: "
#ifdef BIT32ENV
"%p"
#else
"%Fp"
#endif
" buffer address, %ld bytes used, %ld bytes capacity, "
"current position %ld%s%s",
imf->buffer,
imf->inUse,
imf->length,
imf->position,
imeof(imf) ? ", EOF" : "",
imerror(imf) ? ", ERROR" : "");
#endif
else if (imf->filename != NULL)
{
/* Only report the file is on disk once */
if ((imf->flag & IM_FLAG_DISKR) == 0)
{
imf->flag |= IM_FLAG_DISKR;
printmsg(5,"imStatus: File resides on disk as %s with %ld bytes",
imf->filename,
imlength( imf ));
}
}
else
printmsg(5,"imstatus: No backing store exists for file");
} /* imStatus */
int main(int argc,char** argv)
{
const char* server_name;
int port =__COMMON_PORT__;
if (argc > 2) {
port = atoi(argv[2]);
if(port <= 0) {
printmsg("DIE! Invalid port");
exit(1);
}
}
if (argc > 1) {
server_name = argv[1];
}
else {
server_name = "localhost";
}
if(signal(SIGPIPE,SIG_IGN)==SIG_ERR) {
printmsg("DIE! signal(SIGPIPE)");
exit(1);
}
sOperacion ops[500];
int totalops = cargar_archivo(&ops[0]);
main_proc(server_name,port,ops,totalops);
}
void ddelay( const KEWSHORT milliseconds )
{
MSG msg;
WORD TimerId = 1;
BOOL bTimerDone = KWFalse;
/*--------------------------------------------------------------------*/
/* A 0-delay call means give up control to Windows */
/*--------------------------------------------------------------------*/
if (milliseconds == 0)
{
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return;
}
TimerId = SetTimer( hOurWindow,
TimerId,
(milliseconds > 55) ? (WORD)milliseconds : (WORD)55 ,
NULL );
if ( TimerId == 0 )
{
printmsg(0, "WindowsDelay: Unable to set Windows Timer");
panic();
return;
} /* if */
/*--------------------------------------------------------------------*/
/* LOCAL MESSAGE LOOP - Service Windows while waiting for */
/* the timer message. */
/*--------------------------------------------------------------------*/
while(!bTimerDone && GetMessage(&msg, NULL, NULL, NULL))
{
TranslateMessage(&msg);
switch( msg.message )
{
case WM_TIMER:
bTimerDone = KWTrue;
/* Fall through and dispatch message */
default:
DispatchMessage(&msg);
break;
} /* switch( msg.message ) */
} /* while */
if (KillTimer( hOurWindow, TimerId ) == 0)
printmsg(0, "WindowsDelay: Unable to kill Windows Timer %d",
(int) TimerId );
} /* ddelay */
/* Check if negative offsets are handled correctly by mmap. */
static int
do_test (void)
{
const int prot = PROT_READ | PROT_WRITE;
const int flags = MAP_SHARED;
const unsigned long length = 0x10000;
const unsigned long offset = 0xace00000;
const unsigned long size = offset + length;
void *addr;
int fd;
char fname[] = "tst-mmap-offset-XXXXXX";
fd = mkstemp64 (fname);
if (fd < 0)
return printmsg (1, "mkstemp");
if (unlink (fname))
return printmsg (1, "unlink");
if (ftruncate64 (fd, size))
return printmsg (0, "ftruncate64");
addr = mmap (NULL, length, prot, flags, fd, offset);
if (MAP_FAILED == addr)
return printmsg (1, "mmap");
/* This memcpy is likely to SIGBUS if mmap has messed up with offset. */
memcpy (addr, fname, sizeof (fname));
return 0;
}
void iflowcontrol( KWBoolean flow )
{
#ifdef ARTICOMM_INT14 /* Richard H. Gumpertz ([email protected]), 28 Sep 1993 */
union REGS regs; /* Scratch area for interrupt calls. */
/*
With INT14, don't open and close the port; toggle it in place
by using INT14/AX=800A, which is again Artisoft-specific.
*/
printmsg(4, "iflowcontrol: %sabling in-band flow control",
(flow ? "en" : "dis"));
regs.x.ax = 0x800A;
regs.h.bl = (unsigned char) (flow ? 2 : 1);
/* 2 is hardware, 1 is XON/XOFF */
regs.x.dx = portNum;
int86(0x14, ®s, ®s);
#else /* ARTICOMM_INT14 */
if (flow)
{
printmsg(4, "iflowcontrol: in-band flow control not supported");
}
#endif /* ARTICOMM_INT14 */
ShowModem();
} /* iflowcontrol */
KWBoolean pWinSockInit( void )
{
/*--------------------------------------------------------------------*/
/* Load the library */
/*--------------------------------------------------------------------*/
if (!hWinsock)
hWinsock = LoadLibrary("WINSOCK.DLL");
else {
printmsg(0,"pWinSockInit: called twice with no termination");
panic();
}
if (!hWinsock)
{
printmsg(0, "pWinSockInit: could not find Winsock.DLL");
return KWFalse;
}
/*--------------------------------------------------------------------*/
/* Initialize pointers to functions with in the libraries */
/*--------------------------------------------------------------------*/
#ifdef __TURBOC__
#pragma warn -sus
#endif
paccept = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 1,0));
pbind = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 2,0));
pclosesocket = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 3,0));
pconnect = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 4,0));
phtonl = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 8,0));
phtons = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 9,0));
pinet_addr = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 10,0));
plisten = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 13,0));
pntohl = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 14,0));
pntohs = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 15,0));
precv = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 16,0));
pselect = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 18,0));
psend = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 19,0));
psetsockopt = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 21,0));
pshutdown = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 22,0));
psocket = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 23,0));
pgethostbyname = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 52,0));
pgetservbyname = GetProcAddress(hWinsock, (LPSTR)MAKELONG( 55,0));
pWSAGetLastError = GetProcAddress(hWinsock, (LPSTR)MAKELONG(111,0));
pWSACancelBlockingCall = GetProcAddress(hWinsock, (LPSTR)MAKELONG(113,0));
pWSAIsBlocking = GetProcAddress(hWinsock, (LPSTR)MAKELONG(114,0));
pWSAStartup = GetProcAddress(hWinsock, (LPSTR)MAKELONG(115,0));
pWSACleanup = GetProcAddress(hWinsock, (LPSTR)MAKELONG(116,0));
#ifdef __TURBOC__
#pragma warn .sus
#endif
return KWTrue;
} /* pWinSockInit */
bool viewcmd(char *itemName, CFErrorRef *err) {
char *cmd, *viewname;
SOSViewActionCode ac = kSOSCCViewQuery;
CFStringRef viewspec;
viewname = strchr(itemName, ':');
if(viewname == NULL) return false;
*viewname = 0;
viewname++;
cmd = itemName;
if(strcmp(cmd, "enable") == 0) {
ac = kSOSCCViewEnable;
} else if(strcmp(cmd, "disable") == 0) {
ac = kSOSCCViewDisable;
} else if(strcmp(cmd, "query") == 0) {
ac = kSOSCCViewQuery;
} else {
return false;
}
if(strchr(viewname, ',') == NULL) { // original single value version
viewspec = convertStringToView(viewname);
if(!viewspec) return false;
SOSViewResultCode rc = SOSCCView(viewspec, ac, err);
CFStringRef resultString = convertViewReturnCodeToString(rc);
printmsg(CFSTR("View Result: %@ : %@\n"), resultString, viewspec);
return true;
}
if(ac == kSOSCCViewQuery) return false;
// new multi-view version
char *viewlist = strdup(viewname);
char *token;
char *tofree = viewlist;
CFMutableSetRef viewSet = CFSetCreateMutable(NULL, 0, &kCFCopyStringSetCallBacks);
while ((token = strsep(&viewlist, ",")) != NULL) {
CFStringRef resultString = convertStringToView(token);
CFSetAddValue(viewSet, resultString);
}
printmsg(CFSTR("viewSet provided is %@\n"), viewSet);
free(tofree);
bool retcode;
if(ac == kSOSCCViewEnable) retcode = SOSCCViewSet(viewSet, NULL);
else retcode = SOSCCViewSet(NULL, viewSet);
fprintf(outFile, "SOSCCViewSet returned %s\n", (retcode)? "true": "false");
return true;
}
static KWBoolean
AutoBounceSMTP(
int status,
IMFILE *imf,
const MAIL_ADDR *sender,
SMTP_ADDR *toAddress,
int count,
const char *relay,
const KWBoolean validate,
const unsigned int timeout
)
{
int subscript;
switch(status)
{
case KWNSSuccess:
/* No problem, so do not force termination */
return KWFalse;
case KWNSNoNet:
printmsg(0,"Network connection lost with %s"
", requeuing for retry.",
relay);
shutdownSMTP(0);
return KWTrue;
case KWNSNetTimeout:
printmsg(0,"Network timeout occurred, breaking off exchange with %s"
" and requeuing for retry.",
relay );
shutdownSMTP(timeout);
return KWTrue;
case KWNSTransientError:
printmsg(0,"Transient procotol error with %s"
", requeuing for retry.",
relay);
shutdownSMTP(timeout);
return KWTrue;
default:
Bounce(imf,
sender,
"SMTP Protocol Permanent Error occurred",
GET_TRACE_BUFFER(),
relay,
validate);
/* Treat all bounced addresses as processed */
for (subscript = 0; subscript < count; subscript++)
toAddress[subscript].processed = KWTrue;
return KWTrue;
} /* switch(status) */
} /* SMTPAutoBounce */
unsigned long getSeq()
{
char seqfile[FILENAME_MAX];
FILE *stream;
unsigned long seq = 0;
mkfilename(seqfile, E_spooldir, SFILENAME);
if ((stream = FOPEN(seqfile, "r+", IMAGE_MODE)) == nil(FILE))
{
printerr( seqfile );
if ((stream = FOPEN(seqfile, "w", IMAGE_MODE)) == nil(FILE))
{
printerr( seqfile );
panic();
}
}
else {
if ( fread( &seq, sizeof seq, 1, stream ) != 1 )
printerr( seqfile );
}
/*--------------------------------------------------------------------*/
/* Generate a new seed for our sequence if we can't read one */
/*--------------------------------------------------------------------*/
if ( ! seq++ )
{
seq = ((unsigned long) getpid()) % 10000000;
/* Start number small, semi-unique*/
printmsg(0,"Resetting sequence number to %lu (0x%08lx)",
seq,
seq );
}
/*--------------------------------------------------------------------*/
/* Update sequence number */
/*--------------------------------------------------------------------*/
rewind( stream );
if ((fwrite( &seq, sizeof seq, 1, stream ) != 1) || fclose(stream))
{
printerr( seqfile );
panic();
}
#ifdef UDEBUG
printmsg(8, "getseq: seq#=%ld", seq);
#endif
return seq;
} /* getseq */
void
freeBuf( void *oldBuffer, const char *file, const size_t line )
{
while( top != NULL )
{
BUFQUEUE *save = top;
KWBoolean done = (KWBoolean) ( top->userBuffer == oldBuffer ?
KWTrue : KWFalse );
if ( top->signature != SIGNATURE )
{
printmsg(0, "freeBuf: Invalid buffer queue at %p", top );
bugout( file, line );
}
if ( top->userBuffer == oldBuffer )
done = KWTrue;
#ifdef UDEBUG
printmsg(done ? 8 : 2,"%s(%d): freeBuf: %slicit "
"free of %p (%d,%d) for %u bytes",
file,
line,
done ? "ex" : "im",
top,
top->entry,
entries,
top->length );
entries--;
#endif
/*--------------------------------------------------------------------*/
/* Pop the current entry off the stack and free it */
/*--------------------------------------------------------------------*/
top = top->previous;
free( save );
if ( done )
return;
} /* while( top != NULL ) */
/*--------------------------------------------------------------------*/
/* If we didn't find the block to free, we have a serious */
/* internal error -- report it and exit. */
/*--------------------------------------------------------------------*/
printmsg( 0, "freeBuf: Unable to locate requested memory block at %p",
oldBuffer );
bugout( file, line );
} /* freeBuf */
static void
gotpacket(char msg[], int len)
{
int i;
/* What did we get? */
switch (msg[0]) {
case 'a':
break;
case 'b':
printmsg(msg, len, 0);
break;
case 'c':
printmsg(msg, len, 1);
break;
case 'd':
case 'f':
printmsg(msg, len, 2);
break;
case 'e':
timestamp();
fprintf(stdout, "%s ", tbuf);
fputs("-!- [Error] ", stdout);
for (i = 1; i < len; i++)
fputc(msg[i], stdout);
fputc('\n', stdout);
break;
case 'g':
timestamp();
fprintf(stdout, "%s ", tbuf);
fputs("-!- [Error] Connection closed by server\n", stdout);
running = 0;
break;
case 'i':
printicmd(msg, len);
break;
case 'j':
sendlogin(); /* Now we can log in. */
break;
case 'k':
timestamp();
fprintf(stdout, "%s ", tbuf);
fputs("-!- [Beep] You were beeped by ", stdout);
for (i = 1; i < len; i++)
fputc(msg[i], stdout);
fputc('\n', stdout);
break;
case 'l':
case 'm':
break;
default:
fputs("Received invalid packet.\n", stdout);
break;
}
}
static KWBoolean internal( const char *command )
{
static char *commands[] = { "break", "cd", "chdir", "copy",
"ctty", "date", "del", "dir",
"echo", "erase", "for", "md",
"mkdir", "rd", "rem", "ren",
"rename", "rmdir", "time", "type",
"ver", "verify", "vol",
NULL };
char **list;
/*--------------------------------------------------------------------*/
/* Empty commands are a special signal to use the command */
/* processor to run the arguments. */
/*--------------------------------------------------------------------*/
if ( *command == '\0' )
{
printmsg(4,"internal: Empty command, using command processor");
return KWTrue;
}
/*--------------------------------------------------------------------*/
/* Determine command list to use */
/*--------------------------------------------------------------------*/
if (E_internal == NULL )
list = commands;
else
list = E_internal;
/*--------------------------------------------------------------------*/
/* Scan the list for the command */
/*--------------------------------------------------------------------*/
while( *list != NULL )
{
if (equali(*list++,command))
{
printmsg(4,"\"%s\" is an internal command",command);
return KWTrue;
} /* if */
} /* while( *list != NULL ) */
/*--------------------------------------------------------------------*/
/* The command is not in the list; return KWFalse (external */
/* command) */
/*--------------------------------------------------------------------*/
printmsg(4,"\"%s\" is an external command",command);
return KWFalse;
} /* internal */
KWBoolean excluded(char *list, char *path)
{
char *t1, *t2, *t3;
int temp;
printmsg(5, "exclude: checking %s against %s", list, path);
t1 = strtok(list, ", ");
while (t1 != NULL)
{
t2 = strstr(path, t1);
while (t2 != NULL)
{
/* MUST be start of string or preceded by '!' */
if ((t2 == path) ||
(*(t2 - 1) == '!'))
{
/* is this the only entry left ? */
if (equal(t1, t2))
return KWTrue;
/* must be directly followed by a '!' */
t3 = strchr(t2, '!');
if (t3 != NULL)
{
*t3 = 0;
temp = strcmp(t1, t2);
*t3 = '!';
if (temp == 0)
return KWTrue;
}
}
/* search for another occurence */
t2 = strstr(t2 + 1, t1);
}
t1 = strtok(NULL, ", ");
} /* while (t1 != NULL) */
printmsg(5, "exclude: results in KWFalse");
return KWFalse;
} /* excluded */
struct UserTable *checkuser(const char *name)
{
int lower;
int upper;
if ( (name == NULL) || (strlen(name) == 0) )
{
printmsg(0,"checkuser: Invalid argument!");
panic();
}
#ifdef UDEBUG
printmsg(14,"checkuser: Searching for user id %s", name);
#endif
/*-------------------------------------------------------------------*/
/* Initialize the host name table if needed */
/*-------------------------------------------------------------------*/
if (userElements == 0) /* host table initialized yet? */
userElements = loaduser(); /* No --> load it */
lower = 0;
upper = (int) userElements - 1;
/*--------------------------------------------------------------------*/
/* Peform a binary search on the user table */
/*--------------------------------------------------------------------*/
while ( lower <= upper )
{
int midpoint;
int hit;
midpoint = (lower + upper) / 2;
hit = stricmp(name,users[midpoint].uid);
if (hit > 0)
lower = midpoint + 1;
else if (hit < 0)
upper = midpoint - 1;
else
return &users[midpoint];
}
/*--------------------------------------------------------------------*/
/* We didn't find the user. Return failure to caller */
/*--------------------------------------------------------------------*/
return BADUSER;
} /* checkuser */
int initCtrl (){
if(!(SDL_Init(SDL_INIT_EVERYTHING))){
SDL_SetEventFilter(eventFilter);
SDL_SetVideoMode(200, 200, 0, 0);
// SDL_WM_GrabInput(SDL_GRAB_ON);
// If gamepad mode specified, open gamepad
if(ctrlmode == GAMEPAD){
int num_pads;
// If more than one joystick attached, let user choose which one
if((num_pads = SDL_NumJoysticks()) > 1){
sprintf(termbuf, "Select gamepad index (number from 0 to %d): ", (num_pads-1));
printmsg();
while((pad_index = fgetc(stdin)) == EOF);
}
if((pad = SDL_JoystickOpen(pad_index))){
sprintf(termbuf, "%s opened successfully.\n",
SDL_JoystickName(pad_index));
printmsg();
// Set initial modes
cur_move = MOV_STOP;
cur_turn = TRN_NONE;
cur_h_aim = AIM_H_STRGHT;
cur_v_aim = AIM_V_STRGHT;
cur_fire = FIRE_OFF;
cur_l_strf = STRF_L_OFF;
cur_r_strf = STRF_R_OFF;
SDL_JoystickEventState(SDL_ENABLE);
}
else{
sprintf(termbuf, "Gamepad %s not opened successfully.\nReverting to keyboard control\n",
SDL_JoystickName(pad_index));
printmsg();
ctrlmode = KEYBOARD;
}
}
return -1;
}
return 0;
}
/*----------------------------------------------------------------
* main
*
* wlanctl-ng entry point.
*
* Arguments:
* argc number of command line arguments
* argv array of argument strings
*
* Returns:
* 0 - success
* ~0 - failure
----------------------------------------------------------------*/
int main ( int argc, char **argv )
{
UINT8 message[MSG_BUFF_LEN];
UINT32 msgcode = P80211DID_INVALID;
INT result = 0;
INT i;
if ( argc < 4 && argc >= 2 && strcmp( argv[1], "version") == 0) {
printf("wlanctl-ng: %s\n", WLAN_RELEASE);
}
else if ( argc < 4 && argc >= 2 && strcmp( argv[1], "commands") == 0) {
print_allrequests();
}
else if ( argc < 4 && argc >= 2 && strcmp( argv[1], "mibs") == 0) {
print_allmibs();
}
else if ( argc < 3 ) {
usage();
} else {
/* stuff the device name in a global */
devname = argv[1];
/* returns P80211DID_INVALID no match */
for ( i = 0; i < sizeof(cmdcats)/sizeof(cmdcats[0]); i++) {
msgcode = p80211_text2did(msg_catlist,
cmdcats[i], argv[2], NULL);
if ( msgcode != P80211DID_INVALID ) {
break;
}
}
if (msgcode != P80211DID_INVALID) { /* msgcode valid */
result = cmdline2requestmsg( message, msgcode, argc, argv );
if ( result == 0 ) {
if ( (result = do_ioctl( message, msgcode )) == 0 ){
printmsg( message, msgcode );
}
} else {
printmsg( message, msgcode );
/*
printf("Message \"%s\" was unable to be created\n", argv[2]);
*/
}
} else { /* msgcode invalid */
printf("The cmd \'%s\' is invalid\n", argv[2]);
result=msgcode;
}
}
return(result);
}
static KWNetStatus
SendSMTPCmd(
char *cmd /* IN The command to send */
)
{
char buffer[KW_BUFSIZ];
int len = (int) strlen(cmd);
KWBoolean buffered = KWFalse;
bufferTrace(">>>", cmd, len);
/*--------------------------------------------------------------------*/
/* Buffer the command if possible to allow appending the */
/* CR/LF for transmission of the resulting logical line as */
/* one network write. */
/*--------------------------------------------------------------------*/
if (sizeof buffer > (len + 3))
{
strcpy(buffer, cmd);
strcpy(buffer + len, CRLF);
len += CRLF_LEN;
cmd = buffer;
buffered = KWTrue;
}
/*--------------------------------------------------------------------*/
/* Actually perform the network write of the command */
/*--------------------------------------------------------------------*/
if (swrite(cmd, len) < len)
{
printmsg(0,"Error sending command to remote host");
return KWNSNoNet;
}
/*--------------------------------------------------------------------*/
/* If the command was not buffered, write the trailing CR/LF */
/*--------------------------------------------------------------------*/
if (!buffered && (swrite(CRLF, CRLF_LEN) < CRLF_LEN))
{
printmsg(0, "Error sending CR/LF to remote host");
return KWNSNoNet;
}
return KWNSSuccess;
} /* SendSMTPCmd */
void safefree( void *input , const char UUFAR *file, size_t line)
{
STR_QUEUE *current = anchor;
int buffers = 0;
while( current != NULL )
{
buffers ++;
if (( input > (void *) current ) &&
(input < (void *) (current->pool + pool_size ) ))
{
printmsg(0,"Attempt to free string \"%s\" allocated via newstr() in pool %d",
input , buffers );
bugout( file, line);
}
current = current->next_link;
}
#undef free
free(input);
} /* safefree */
int main() {
char str[10] = "<1E2F1>";
printmsg(str);
}
extern DIR *opendirx( const char *dirname, char *pattern)
{
union REGS inregs, outregs;
struct SREGS segregs;
char pathname[FILENAME_MAX];
DTA far *dtasave;
DTA far *dtaptr;
char far *pathptr;
/*--------------------------------------------------------------------*/
/* Build pathname to be scanned */
/*--------------------------------------------------------------------*/
strcpy(pathname, dirname);
if ((*pattern != '/') || (dirname[ strlen(dirname) - 1] != '/'))
strcat(pathname,"/");
strcat(pathname, pattern);
/* allocate control block */
thisDirP = malloc(sizeof(DIR));
checkref( thisDirP );
/*--------------------------------------------------------------------*/
/* Set disk transfer address */
/*--------------------------------------------------------------------*/
dtasave = (DTA far *)getdta();
dtaptr = (DTA far *)&(thisDirP->dirdta);
setdta((char far *)dtaptr);
/*--------------------------------------------------------------------*/
/* look for the first file */
/*--------------------------------------------------------------------*/
inregs.h.ah = 0x4e;
pathptr = (char far *)pathname;
segregs.ds = FP_SEG(pathptr);
inregs.x.dx = FP_OFF(pathptr);
inregs.x.cx = 0; /* attribute */
intdosx(&inregs, &outregs, &segregs);
/* bad directory name? */
if (outregs.x.cflag && (outregs.x.ax == 2 || outregs.x.ax == 3)) {
free(thisDirP);
return NULL;
}
thisDirP->dirfirst = outregs.x.cflag ? outregs.x.ax : 0;
setdta((char far *)dtasave);
strcpy(thisDirP->dirid, "DIR");
#ifdef UDEBUG
printmsg(2,"opendir: Address is %p", thisDirP );
#endif
openForBusiness = KWTrue;
return thisDirP;
} /*opendir*/
int cargar_archivo(sOperacion* ops)
{
char mensaje[__TCP_MSG_LEN__];
int totalops=0;
/* leo las operaciones del archivo */
FILE* f;
f=stdin;
while(!feof(f)) {
if(fgets(mensaje,__TCP_MSG_LEN__,f)==NULL) {
printmsg("Error reading file");
exit(1);
}
int size = strlen(mensaje) - 1; /* op|data|\n */
if(mensaje[size] == '\n') {
mensaje[size] = '\0';
size--;
}
ops[totalops].size = size;
ops[totalops].op = mensaje[0]-38;
strcpy(ops[totalops].data,&mensaje[1]);
totalops++;
}
fclose(f);
return totalops;
}
static int RunningUnderDesqview(void)
{
static int result = 2;
union REGS inregs, outregs;
if (result != 2) /* First call? */
return result; /* No --> Return saved result */
inregs.x.ax = 0x2B01; /* Dos Set Date function */
inregs.x.cx = 0x4445; /* CX DX = 'DESQ' */
inregs.x.dx = 0x5351;
intdos(&inregs, &outregs);
if (outregs.h.al == 0xff) {
result = 0;
} else {
printmsg(4, "RunningUnderDesqview: Running under DesqView (AX=0x%x)",
(int) outregs.x.ax);
result = 1;
}
return result;
} /* RunningUnderDesqview */
int imprintf(IMFILE *imf, const char *fmt, ...)
{
va_list arg_ptr;
va_start(arg_ptr,fmt);
if (imf->buffer == NULL)
return vfprintf(imf->stream, fmt, arg_ptr);
else {
char buffer[4096];
int result = vsprintf(buffer, fmt, arg_ptr);
if (result == EOF)
return EOF;
if (result > (sizeof buffer))
{
printmsg(0, "imprintf: Memory overflow processing im memory file");
panic(); /* We corrupted the stack! */
}
if (imputs(buffer, imf) == result)
return result;
else
return EOF;
} /* else */
} /* imprintf */
int imclose(IMFILE *imf)
{
int result = 0;
if (imf == NULL)
{
printmsg(0,"imclose: Close called with NULL pointer");
panic();
}
imStatus(imf);
if (imf->buffer != NULL)
FREE(imf->buffer);
if (imf->stream != NULL)
{
result = fclose(imf->stream);
REMOVE(imf->filename);
}
if (imf->filename != NULL)
free(imf->filename);
#ifdef UDEBUG
memset(imf, 0, sizeof *imf);
#endif
free(imf);
return result;
} /* imclose */
void bugout( const size_t lineno, const char *fname )
{
printmsg(0,"Program aborting at line %d in file %s",
lineno, fname );
fcloseall();
exit(69);
} /*bugout */
static void ShowModem( void )
{
static int oldStatus = 0xDEAD;
int status;
if ( debuglevel < 4 )
return;
status = FSStatus();
if (status == oldStatus)
return;
printmsg(0, "ShowModem: %#02x%s%s%s%s%s%s%s%s",
status,
mannounce(MDM_CD, status, "\tCarrier Detect"),
mannounce(MDM_RI, status, "\tRing Indicator"),
mannounce(MDM_DSR, status, "\tData Set Ready"),
mannounce(MDM_CTS, status, "\tClear to Send"),
mannounce(MDM_CDC, status, "\tCD changed"),
mannounce(MDM_TRI, status, "\tRI went OFF"),
mannounce(MDM_DSRC, status, "\tDSR changed"),
mannounce(MDM_CTSC, status, "\tCTS changed"));
oldStatus = status;
} /* ShowModem */
short fsendpkt(char *ip, short len)
{
char *op;
short sum, nl;
short ret;
char obuf[MAXPACK * 2];
op = obuf;
nl = 0;
sum = chksum;
if (len == 0)
{
printmsg(0,"fsendpkt: Internal error: zero length for packet");
return DCP_FAILED;
}
do {
if (sum & 0x8000) {
sum <<= 1;
sum++;
} else
sum <<= 1;
sum += (short) (*ip & 0377);
sum &= 0xffff;
if (*ip & 0200) {
*ip &= 0177;
if (*ip < 040) {
*op++ = '\174';
*op++ = (char) (*ip++ + 0100);
} else
if (*ip <= 0171) {
*op++ = '\175';
*op++ = *ip++;
}
else {
*op++ = '\176';
*op++ = (char) (*ip++ - 0100);
}
nl += 2;
} else {
if (*ip < 040) {
*op++ = '\172';
*op++ = (char) (*ip++ + 0100);
nl += 2;
} else
if (*ip <= 0171) {
*op++ = *ip++;
nl++;
} else {
*op++ = '\173';
*op++ = (char) (*ip++ - 0100);
nl += 2;
}
}
} while (--len > 0);
chksum = sum;
ret = (short) swrite(obuf, nl);
if ( ret == nl )
return DCP_OK;
else
return DCP_FAILED;
} /* fsendpkt */
void printfiller (char c, int count)
{
int i;
for (i = 0; i < count; i++)
printmsg("%c", c);
}
char *jobNumber( const unsigned long sequenceIn,
const size_t lengthIn,
const KWBoolean monocase )
{
static char buf[10];
static const char set[] =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
unsigned long sequence = sequenceIn;
size_t length = lengthIn;
const int base = (sizeof set - 1) - (monocase ? 26 : 0);
char *p = buf + sizeof buf - 2;
if ( length >= sizeof buf ) /* User want too many digits? */
length = sizeof buf - 1; /* Yes --> Limit the string */
while( length-- > 0 )
{
*p-- = set[ (size_t) (sequence % base) ];
sequence /= base ;
} /* while */
p++; /* Step back to first character */
printmsg(5, "jobNumber: seq#=%ld, length = %u, job id = \"%s\"",
sequenceIn,
lengthIn,
p);
return p;
} /* jobNumber */
