Ejemplo n.º 1
0
char *_V_strupr (const char* file, int line, char *start)
{
	AssertValidStringPtr( start );
	return strupr( start );
}
Ejemplo n.º 2
0
OM_uint32 GSSAPI_CALLCONV
_gss_ntlm_import_name
           (OM_uint32 * minor_status,
            const gss_buffer_t input_name_buffer,
            const gss_OID input_name_type,
            gss_name_t * output_name
           )
{
    char *name, *p, *p2;
    int is_hostnamed;
    int is_username;
    ntlm_name n;

    *minor_status = 0;

    if (output_name == NULL)
	return GSS_S_CALL_INACCESSIBLE_WRITE;

    *output_name = GSS_C_NO_NAME;

    is_hostnamed = gss_oid_equal(input_name_type, GSS_C_NT_HOSTBASED_SERVICE);
    is_username = gss_oid_equal(input_name_type, GSS_C_NT_USER_NAME);

    if (!is_hostnamed && !is_username)
	return GSS_S_BAD_NAMETYPE;

    name = malloc(input_name_buffer->length + 1);
    if (name == NULL) {
	*minor_status = ENOMEM;
	return GSS_S_FAILURE;
    }
    memcpy(name, input_name_buffer->value, input_name_buffer->length);
    name[input_name_buffer->length] = '\0';

    /* find "domain" part of the name and uppercase it */
    p = strchr(name, '@');
    if (p == NULL) {
        free(name);
	return GSS_S_BAD_NAME;
    }
    p[0] = '\0';
    p++;
    p2 = strchr(p, '.');
    if (p2 && p2[1] != '\0') {
	if (is_hostnamed) {
	    p = p2 + 1;
	    p2 = strchr(p, '.');
	}
	if (p2)
	    *p2 = '\0';
    }
    strupr(p);

    n = calloc(1, sizeof(*n));
    if (n == NULL) {
	free(name);
	*minor_status = ENOMEM;
	return GSS_S_FAILURE;
    }

    n->user = strdup(name);
    n->domain = strdup(p);

    free(name);

    if (n->user == NULL || n->domain == NULL) {
	free(n->user);
	free(n->domain);
	free(n);
	*minor_status = ENOMEM;
	return GSS_S_FAILURE;
    }

    *output_name = (gss_name_t)n;

    return GSS_S_COMPLETE;
}
Ejemplo n.º 3
0
readpost()					/* umm.... Read post! */
{
int c,curmsg,dir;
char s[80], x[10];

gettotalmsgs();

nl();
nl();
if(totalmsgs==0)
	{
	pl("4No messages exist");
	return;
	}

print("1Start with which post [31-%d1]:2 ",totalmsgs);
input(s,50);
if(s[0]==0)
	return;

c=atoi(s);

if(c > totalmsgs)
	{
	nl();
	pl("4Not that many posts!");
	return;
	}

curmsg=c;
rdpost(c);
dir=1;

do
	{
	nl();
	if(dir==1)
		print("1C/R=Forward [3B,E,F,P,Q,R,+,-,?,#1]:2 ");
	else
		print("1C/R=Reverse [3B,E,F,P,Q,R,+,-,?,#1]:2 ");
	input(s,50);
	strupr(s);
	switch(s[0])
		{
		case 0:
			if(dir==1)
				{
				if(curmsg >= totalmsgs)
					put("4Last message!");
				else
					{
					curmsg++;
					rdpost(curmsg);
					}
				}
			else
				{
				if(curmsg == 1)
					put("4First message!");
				else
					{
					curmsg--;
					rdpost(curmsg);
					}
				}
			break;
		case 'B':
			nl();
			pl("4Reverse read mode enabled");
			dir=-1;
			break;
		case 'E':
			break;
		case 'F':
			nl();
			pl("4Forward read mode enabled");
			dir=1;
			break;
		case 'P':
			post(0,curmsg);
			break;
		case 'Q':
			break;
		case 'R':
			post(1,curmsg);
			break;
		case '+':
			gethead(curmsg);
			if(hdr.lastrep!=0)
				{
				for(c=1;c;)
					{
					if(hdr.lastrep!=0)
						{
						rdpost(hdr.lastrep+1);
						nl();
						put("1Forward Thread Scan - Q to Quit, C/R to continue:2 ");
						input(x,10);
						strupr(x);
						if(x[0]=='Q')
							c=0;
						}
					else
						{
						print("4\bNo replies found");
						c=0;
						}
					}
				}
			else
				print("4\bNo replies found");
			nl();
			break;
		case '-':
			gethead(curmsg);
			if(hdr.prevrep!=0)
				{
				for(c=1;c;)
					{
					if(hdr.prevrep!=0)
						{
						rdpost(hdr.prevrep);
						nl();
						put("1Reverse Thread Scan - Q to Quit, C/R to continue:2 ");
						input(x,10);
						strupr(x);
						if(x[0]=='Q')
							c=0;
						}
					else
						{
						print("4\bNo replies found");
						c=0;
						}
					}
				}
			else
				print("4\bNo replies found");
			nl();
			break;
		case '?':
			nl();
			nl();
			ansic(4);
			pl("��] Message Read Commands [��");
			pl("  B - Reverse read");
			pl("  E - E-mail poster");
			pl("  F - Forward read");
			pl("  P - Post a message");
			pl("  Q - Quit reading messages");
			pl("  R - Reply to poster");
			pl("  - - Reverse thread read");
			pl("  + - Forward thread read");
			pl("  # - Message number");
			nl();
			break;
		default:
			c=atoi(s);
			if(c > 0 && c <= totalmsgs)
				{
				curmsg=c;
				rdpost(curmsg);
				}
			break;
		}
	} while(s[0]!='Q');
nl();
nl();
}
Ejemplo n.º 4
0
int KILL_PROC_BY_NAME(const TCHAR *szToTerminate)
// Created: 6/23/2000  (RK)
// Last modified: 3/10/2002  (RK)
// Please report any problems or bugs to [email protected]
// The latest version of this routine can be found at:
//     http://www.neurophys.wisc.edu/ravi/software/killproc/
// Terminate the process "szToTerminate" if it is currently running
// This works for Win/95/98/ME and also Win/NT/2000/XP
// The process name is case-insensitive, i.e. "notepad.exe" and "NOTEPAD.EXE"
// will both work (for szToTerminate)
// Return codes are as follows:
//   0   = Process was successfully terminated
//   603 = Process was not currently running
//   604 = No permission to terminate process
//   605 = Unable to load PSAPI.DLL
//   602 = Unable to terminate process for some other reason
//   606 = Unable to identify system type
//   607 = Unsupported OS
//   632 = Invalid process name
//   700 = Unable to get procedure address from PSAPI.DLL
//   701 = Unable to get process list, EnumProcesses failed
//   702 = Unable to load KERNEL32.DLL
//   703 = Unable to get procedure address from KERNEL32.DLL
//   704 = CreateToolhelp32Snapshot failed
// Change history:
//   modified 3/8/2002  - Borland-C compatible if BORLANDC is defined as
//                        suggested by Bob Christensen
//   modified 3/10/2002 - Removed memory leaks as suggested by
//					      Jonathan Richard-Brochu (handles to Proc and Snapshot
//                        were not getting closed properly in some cases)
{
	BOOL bResult,bResultm;
	DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	DWORD iCbneeded,i,iFound=0;
	TCHAR szName[MAX_PATH],szToTermUpper[MAX_PATH];
	HANDLE hProc,hSnapShot,hSnapShotm;
	OSVERSIONINFO osvi;
	HINSTANCE hInstLib;
	int iLen,iLenP,indx;
	HMODULE hMod;
	PROCESSENTRY32 procentry;      
	MODULEENTRY32 modentry;

	// Transfer Process name into "szToTermUpper" and
	// convert it to upper case
	iLenP=(int)wcslen(szToTerminate);
	if(iLenP<1 || iLenP>MAX_PATH) return 632;
	for(indx=0;indx<iLenP;indx++)
		szToTermUpper[indx]=toupper(szToTerminate[indx]);
	szToTermUpper[iLenP]=0;

	// PSAPI Function Pointers.
	BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
	BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
		DWORD, LPDWORD );
	DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
		LPTSTR, DWORD );

	// ToolHelp Function Pointers.
	HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
	BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
	BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
	BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
	BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;

	// First check what version of Windows we're in
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	bResult=GetVersionEx(&osvi);
	if(!bResult)     // Unable to identify system version
		return 606;

	// At Present we only support Win/NT/2000/XP or Win/9x/ME
	if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
		(osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
		return 607;

	if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
	{
		// Win/NT or 2000 or XP

		// Load library and get the procedures explicitly. We do
		// this so that we don't have to worry about modules using
		// this code failing to load under Windows 9x, because
		// it can't resolve references to the PSAPI.DLL.
		hInstLib = LoadLibraryA("PSAPI.DLL");
		if(hInstLib == NULL)
			return 605;

		// Get procedure addresses.
		lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
			GetProcAddress( hInstLib, "EnumProcesses" ) ;
		lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
			DWORD, LPDWORD)) GetProcAddress( hInstLib,
			"EnumProcessModules" ) ;
		lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
			LPTSTR, DWORD )) GetProcAddress( hInstLib,
			"GetModuleBaseNameW" ) ;

		if(lpfEnumProcesses == NULL ||
			lpfEnumProcessModules == NULL ||
			lpfGetModuleBaseName == NULL)
		{
			FreeLibrary(hInstLib);
			return 700;
		}

		bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
		if(!bResult)
		{
			// Unable to get process list, EnumProcesses failed
			FreeLibrary(hInstLib);
			return 701;
		}

		// How many processes are there?
		iNumProc=iCbneeded/sizeof(DWORD);

		// Get and match the name of each process
		for(i=0;i<iNumProc;i++)
		{
			// Get the (module) name for this process

			wcscpy_s(szName,L"Unknown");
			// First, get a handle to the process
			hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
				aiPID[i]);
			// Now, get the process name
			if(hProc)
			{
				if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
				{
					iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
				}
			}
			CloseHandle(hProc);
			// We will match regardless of lower or upper case
#ifdef BORLANDC
			if(strcmp(strupr(szName),szToTermUpper)==0)
#else
			if(wcscmp(_wcsupr(szName),szToTermUpper)==0)
#endif
			{
				// Process found, now terminate it
				iFound=1;
				// First open for termination
				hProc=OpenProcess(PROCESS_TERMINATE,FALSE,aiPID[i]);
				if(hProc)
				{
					if(TerminateProcess(hProc,0))
					{
						// process terminated
						CloseHandle(hProc);
						FreeLibrary(hInstLib);
						return 0;
					}
					else
					{
						// Unable to terminate process
						CloseHandle(hProc);
						FreeLibrary(hInstLib);
						return 602;
					}
				}
				else
				{
					// Unable to open process for termination
					FreeLibrary(hInstLib);
					return 604;
				}
			}
		}
	}

	if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
	{
		// Win/95 or 98 or ME

		hInstLib = LoadLibraryA("Kernel32.DLL");
		if( hInstLib == NULL )
			return 702;

		// Get procedure addresses.
		// We are linking to these functions of Kernel32
		// explicitly, because otherwise a module using
		// this code would fail to load under Windows NT,
		// which does not have the Toolhelp32
		// functions in the Kernel 32.
		lpfCreateToolhelp32Snapshot=
			(HANDLE(WINAPI *)(DWORD,DWORD))
			GetProcAddress( hInstLib,
			"CreateToolhelp32Snapshot" ) ;
		lpfProcess32First=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32First" ) ;
		lpfProcess32Next=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32Next" ) ;
		lpfModule32First=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32First" ) ;
		lpfModule32Next=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32Next" ) ;
		if( lpfProcess32Next == NULL ||
			lpfProcess32First == NULL ||
			lpfModule32Next == NULL ||
			lpfModule32First == NULL ||
			lpfCreateToolhelp32Snapshot == NULL )
		{
			FreeLibrary(hInstLib);
			return 703;
		}

		// The Process32.. and Module32.. routines return names in all uppercase

		// Get a handle to a Toolhelp snapshot of all the systems processes.

		hSnapShot = lpfCreateToolhelp32Snapshot(
			TH32CS_SNAPPROCESS, 0 ) ;
		if( hSnapShot == INVALID_HANDLE_VALUE )
		{
			FreeLibrary(hInstLib);
			return 704;
		}

		// Get the first process' information.
		procentry.dwSize = sizeof(PROCESSENTRY32);
		bResult=lpfProcess32First(hSnapShot,&procentry);

		// While there are processes, keep looping and checking.
		while(bResult)
		{
			// Get a handle to a Toolhelp snapshot of this process.
			hSnapShotm = lpfCreateToolhelp32Snapshot(
				TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
			if( hSnapShotm == INVALID_HANDLE_VALUE )
			{
				CloseHandle(hSnapShot);
				FreeLibrary(hInstLib);
				return 704;
			}
			// Get the module list for this process
			modentry.dwSize=sizeof(MODULEENTRY32);
			bResultm=lpfModule32First(hSnapShotm,&modentry);

			// While there are modules, keep looping and checking
			while(bResultm)
			{
				if(wcscmp(modentry.szModule,szToTermUpper)==0)
				{
					// Process found, now terminate it
					iFound=1;
					// First open for termination
					hProc=OpenProcess(PROCESS_TERMINATE,FALSE,procentry.th32ProcessID);
					if(hProc)
					{
						if(TerminateProcess(hProc,0))
						{
							// process terminated
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
							FreeLibrary(hInstLib);
							return 0;
						}
						else
						{
							// Unable to terminate process
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
							FreeLibrary(hInstLib);
							return 602;
						}
					}
					else
					{
						// Unable to open process for termination
						CloseHandle(hSnapShotm);
						CloseHandle(hSnapShot);
						FreeLibrary(hInstLib);
						return 604;
					}
				}
				else
				{  // Look for next modules for this process
					modentry.dwSize=sizeof(MODULEENTRY32);
					bResultm=lpfModule32Next(hSnapShotm,&modentry);
				}
			}

			//Keep looking
			CloseHandle(hSnapShotm);
			procentry.dwSize = sizeof(PROCESSENTRY32);
			bResult = lpfProcess32Next(hSnapShot,&procentry);
		}
		CloseHandle(hSnapShot);
	}
	if(iFound==0)
	{
		FreeLibrary(hInstLib);
		return 603;
	}
	FreeLibrary(hInstLib);
	return 0;
}
Ejemplo n.º 5
0
int main(INT iArgc, PSZ Argv[])
{
APIRET rc;
ULONG ulDiskSize, ulDiskFree;
INT iArg;
INT iPartType;
PSZ pEnd;
PSZ p;

   for (iArg = 1; iArg < iArgc; iArg++)
      {
      strupr(Argv[iArg]);
      if (Argv[iArg][0] == '/')
         {
         switch (Argv[iArg][1])
            {
            case 'V':
               fDetailed = 1;
               if (Argv[iArg][2] == ':' && Argv[iArg][3] == '2')
                  fDetailed = 2;
               if (Argv[iArg][2] == ':' && Argv[iArg][3] == '3')
                  fDetailed = 3;
               if (Argv[iArg][2] == ':' && Argv[iArg][3] == '4')
                  fDetailed = 4;
               break;
            case 'B':
               fShowBootSector = TRUE;
               break;
            case 'P':
               p = &Argv[iArg][2];
               for (;;)
                  {
                  while (*p)
                     {
                     while (isspace(*p))
                        p++;
                     if (!(*p))
                        {
                        printf("ERROR: Expected partition types not found!\n");
                        exit(1);
                        break;
                        }
                     iPartType = strtol(p, &pEnd, 16);
                     if (iPartType > 255)
                        {
                        printf("ERROR: Partition type %X is not valid\n", iPartType);
                        exit(1);
                        }
                     printf("Also including partition types %2.2X.\n", iPartType);
                     rgfFakePart[iPartType] = TRUE;
//                     if (iPartType & PARTITION_HIDDEN)
//                        {
//                        printf("Also including partition types %2.2X.\n", iPartType & ~PARTITION_HIDDEN);
//                        rgfFakePart[iPartType & ~PARTITION_HIDDEN] = TRUE;
//                        }

                     p = pEnd;
                     while (isspace(*p)) p++;
                     if (*p != ',')
                        break;
                     p++;
                     }
                  if (iArg + 1 < iArgc && Argv[iArg+1][0] != '/')
                     {
                     iArg++;
                     p = Argv[iArg];
                     }
                  else
                     break;
                  }
               break;
            default :
               printf("Unknown option %s ignored.\n",
                  Argv[iArg]);
               break;
            }
         }
      else
         printf("Invalid argument %s ignored.\n", Argv[iArg]);
      }


   rc = InitProg();
   if (rc)
      return rc;

   if (usDriveCount > 0 && fDetailed > 2)
      {
      PDRIVEINFO pDrive = rgDrives;
      USHORT usDrive;
      for (usDrive = 0; usDrive < usDriveCount; usDrive++)
         {
         pDrive = &rgDrives[usDrive];
         printf("\n=== Directory structure of FAT32 DRIVE #%d===\n", pDrive->DiskNum);

         rc = OpenDisk(pDrive->DiskNum, &pDrive->hDisk);
         DumpDirectory(pDrive,
            pDrive->bpb.RootDirStrtClus, "X:");
         CheckSpace(pDrive);
#ifdef HENK
         ulDiskSize = DiskSize('F');
         ulDiskFree = DiskFree('F');
#endif


         printf("\n");
         printf("Found:\n");
         printf("Disk size       = %13lu\n", pDrive->ulTotalClusters);
         printf("In use          = %13ld\n", ulTotalClusters);
         printf("Free            = %13ld\n", ulTotalFree);
#ifdef HENK
         printf("Reported by DOS:\n");
         printf("Disk size       = %13lu\n", ulDiskSize / 4096);
         printf("In Use          = %13lu\n", (ulDiskSize - ulDiskFree)/4096);
         printf("Free            = %13lu\n", ulDiskFree / 4096);
         printf("Difference      = %13ld\n", (ulDiskSize - ulDiskFree)/4096 - ulTotalClusters);
#endif

         CloseDisk(pDrive->hDisk);
         pDrive->hDisk = 0;
         }
      }


   return 0;
}
Ejemplo n.º 6
0
static void
mandoc_template(struct getargs *args,
		size_t num_args,
		const char *progname,
		const char *extra_string,
		char *(i18n)(const char *))
{
    size_t i;
    char timestr[64], cmd[64];
    char buf[128];
    const char *p;
    time_t t;

    printf(".\\\" Things to fix:\n");
    printf(".\\\"   * correct section, and operating system\n");
    printf(".\\\"   * remove Op from mandatory flags\n");
    printf(".\\\"   * use better macros for arguments (like .Pa for files)\n");
    printf(".\\\"\n");
    t = time(NULL);
    strftime(timestr, sizeof(timestr), "%B %e, %Y", localtime(&t));
    printf(".Dd %s\n", timestr);
    p = strrchr(progname, '/');
    if(p) p++; else p = progname;
    strlcpy(cmd, p, sizeof(cmd));
    strupr(cmd);

    printf(".Dt %s SECTION\n", cmd);
    printf(".Os OPERATING_SYSTEM\n");
    printf(".Sh NAME\n");
    printf(".Nm %s\n", p);
    printf(".Nd in search of a description\n");
    printf(".Sh SYNOPSIS\n");
    printf(".Nm\n");
    for(i = 0; i < num_args; i++){
	/* we seem to hit a limit on number of arguments if doing
           short and long flags with arguments -- split on two lines */
	if(ISFLAG(args[i]) ||
	   args[i].short_name == 0 || args[i].long_name == NULL) {
	    printf(".Op ");

	    if(args[i].short_name) {
		print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
		printf("Fl %c%s", args[i].short_name, buf);
		if(args[i].long_name)
		    printf(" | ");
	    }
	    if(args[i].long_name) {
		print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
		printf("Fl Fl %s%s%s",
		       args[i].type == arg_negative_flag ? "no-" : "",
		       args[i].long_name, buf);
	    }
	    printf("\n");
	} else {
	    print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
	    printf(".Oo Fl %c%s \\*(Ba Xo\n", args[i].short_name, buf);
	    print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
	    printf(".Fl Fl %s%s\n.Xc\n.Oc\n", args[i].long_name, buf);
	}
    /*
	    if(args[i].type == arg_strings)
		fprintf (stderr, "...");
		*/
    }
    if (extra_string && *extra_string)
	printf (".Ar %s\n", extra_string);
    printf(".Sh DESCRIPTION\n");
    printf("Supported options:\n");
    printf(".Bl -tag -width Ds\n");
    for(i = 0; i < num_args; i++){
	printf(".It Xo\n");
	if(args[i].short_name){
	    printf(".Fl %c", args[i].short_name);
	    print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
	    printf("%s", buf);
	    if(args[i].long_name)
		printf(" ,");
	    printf("\n");
	}
	if(args[i].long_name){
	    printf(".Fl Fl %s%s",
		   args[i].type == arg_negative_flag ? "no-" : "",
		   args[i].long_name);
	    print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
	    printf("%s\n", buf);
	}
	printf(".Xc\n");
	if(args[i].help)
	    printf("%s\n", args[i].help);
    /*
	    if(args[i].type == arg_strings)
		fprintf (stderr, "...");
		*/
    }
    printf(".El\n");
    printf(".\\\".Sh ENVIRONMENT\n");
    printf(".\\\".Sh FILES\n");
    printf(".\\\".Sh EXAMPLES\n");
    printf(".\\\".Sh DIAGNOSTICS\n");
    printf(".\\\".Sh SEE ALSO\n");
    printf(".\\\".Sh STANDARDS\n");
    printf(".\\\".Sh HISTORY\n");
    printf(".\\\".Sh AUTHORS\n");
    printf(".\\\".Sh BUGS\n");
}
Ejemplo n.º 7
0
/*
================
CG_ParseServerinfo

This is called explicitly when the gamestate is first received,
and whenever the server updates any serverinfo flagged cvars
================
*/
void CG_ParseServerinfo( void ) {
	const char	*info;
	char	*mapname;

	info = CG_ConfigString( CS_SERVERINFO );
	cgs.dmflags = atoi( Info_ValueForKey( info, "dmflags" ) );
	cgs.teamflags = atoi( Info_ValueForKey( info, "teamflags" ) );
	cgs.timelimit = atoi( Info_ValueForKey( info, "timelimit" ) );
	cgs.maxclients = 1;
	mapname = Info_ValueForKey( info, "mapname" );
	Com_sprintf( cgs.mapname, sizeof( cgs.mapname ), "maps/%s.bsp", mapname );
	char *p = strrchr(mapname,'/');
	strcpy( cgs.stripLevelName[0], p?p+1:mapname );
	strupr( cgs.stripLevelName[0] );
	for (int i=1; i<STRIPED_LEVELNAME_VARIATIONS; i++)	// clear retry-array
	{
		cgs.stripLevelName[i][0]='\0';
	}
	// be careful with the []-numbers here. Currently I use 0,1,2 for replacements or substitution, and [3] for "INGAME"
	//	I know, if I'd known there was going to be this much messing about I'd have subroutinised it all and done it
	//	neater, but it kinda evolved...   Feel free to bug me if you want to add to it... ?  -Ste.
	//

//FIXME: a better way to handle sound-matched strings from other levels (currently uses levelname+sound as key)

	// additional String files needed for some levels...
	//
	// JKA...
	if (!stricmp(cgs.stripLevelName[0],"YAVIN1B"))
	{
		strcpy( cgs.stripLevelName[1], "YAVIN1");
	}

/*	// JK2...
	if (!stricmp(cgs.stripLevelName[0],"KEJIM_BASE") ||
		!stricmp(cgs.stripLevelName[0],"KEJIM_POST")
		)
	{
		strcpy( cgs.stripLevelName[1], "ARTUS_MINE" );
	}
	if (!stricmp(cgs.stripLevelName[0],"DOOM_DETENTION") ||
		!stricmp(cgs.stripLevelName[0],"DOOM_SHIELDS")
		)
	{
		strcpy( cgs.stripLevelName[1], "DOOM_COMM" );
	}
	if (!stricmp(cgs.stripLevelName[0],"DOOM_COMM"))
	{
		strcpy( cgs.stripLevelName[1], "CAIRN_BAY" );
	}
	if (!stricmp(cgs.stripLevelName[0],"NS_STARPAD"))
	{
		strcpy( cgs.stripLevelName[1], "ARTUS_TOPSIDE" );	// for dream sequence...

		strcpy( cgs.stripLevelName[2], "BESPIN_UNDERCITY" );	// for dream sequence...
	}
	if (!stricmp(cgs.stripLevelName[0],"BESPIN_PLATFORM"))
	{
		strcpy( cgs.stripLevelName[1], "BESPIN_UNDERCITY" );
	}
*/
}
Ejemplo n.º 8
0
/*
void BuildFont(void){
    HFONT font;
    base = glGenLists(96);
    font = CreateFont( -24, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE|DEFAULT_PITCH, "Courier New");
}
*/
void mainmenu_draw(int width,int height)
{
    float lightpos2[4]={0,0,1000,0};
    float tmpls[4]={1.0F,1.0F,1.0F,1.0};
    float tmpld[4]={0.6F,0.6F,0.6F,1.0};
    float tmpla[4]={0.2F,0.2F,0.2F,1.0};
    float ratio;

    if (nethertittle==0) {
        nethertittle=new C3DObject("models/tittle.asc","textures/");
        nethertittle->normalize(7.0);
    } /* if */

    /* Enable Lights, etc.: */
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  // Really Nice Perspective Calculations
    glEnable(GL_LIGHT0);
    glLightfv(GL_LIGHT0,GL_AMBIENT,tmpla);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,tmpld);
    glLightfv(GL_LIGHT0,GL_SPECULAR,tmpls);
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glShadeModel( GL_SMOOTH );
    glCullFace( GL_BACK );
    glFrontFace( GL_CCW );
    glEnable( GL_CULL_FACE );
    glDisable( GL_SCISSOR_TEST );
    glEnable( GL_DEPTH_TEST );

    glLightfv(GL_LIGHT0,GL_POSITION,lightpos2);
    glClearColor(0,0,0,0.0);
    glViewport(0,0,width,height);
    ratio=(float)width/float(height);
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    gluPerspective( 30.0, ratio, 1.0, 1024.0 );
    gluLookAt(0,0,30,0,0,0,0,1,0);

    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    switch(mainmenu_status) {
    case 0:
        glTranslatef(0,3,40-mainmenu_substatus);
        //nethertittle->draw(1.0,1.0,1.0);
        break;
    case 1:
        glTranslatef(0,3,0);
        glPushMatrix();
        glRotatef(sin(mainmenu_substatus*0.02)*5.0f,0,1,0);
        nethertittle->draw(1.0,1.0,1.0);
        glPopMatrix();
        glColor3f(0.5,0.5,1.0);
        glTranslatef(-6,-6,0);
        scaledglprintf2(0.005,0.005,_("1 - START NEW GAME   "));
        glTranslatef(-0,-1,0);
        scaledglprintf2(0.005,0.005,_("2 - REDEFINE KEYBOARD"));
        glTranslatef(0,-1,0);
        scaledglprintf2(0.005,0.005,_("3 - OPTIONS          "));
        glTranslatef(0,-1,0);
        scaledglprintf2(0.005,0.005,_("4 - MAP: %s"),mapname);
        glTranslatef(0,-1,0);
        scaledglprintf2(0.005,0.005,_("5 - EXIT GAME        "));
        break;
    case 2:
    case 4:
    case 5:
    case 6:
        glTranslatef(0,3,mainmenu_substatus);
        nethertittle->draw(1.0,1.0,1.0);
        break;
    case 3:
        glColor3f(0.5,0.5,1.0);
        glTranslatef(0,3.5,0);
        if (SCREEN_X== 320) scaledglprintf(0.005,0.005,_("1 - RESOLUTION:  320x240"));
        if (SCREEN_X== 400) scaledglprintf(0.005,0.005,_("1 - RESOLUTION:  400x300"));
        if (SCREEN_X== 640) scaledglprintf(0.005,0.005,_("1 - RESOLUTION:  640x480"));
        if (SCREEN_X== 800) scaledglprintf(0.005,0.005,_("1 - RESOLUTION:  800x600"));
        if (SCREEN_X==1024) scaledglprintf(0.005,0.005,_("1 - RESOLUTION: 1024x768"));
        if (SCREEN_X==1280) scaledglprintf(0.005,0.005,_("1 - RESOLUTION: 1280x1024"));
        glTranslatef(0,-1,0);
        if (COLOUR_DEPTH== 8) scaledglprintf(0.005,0.005, _("2 - COLOR DEPTH:  8bit  "));
        if (COLOUR_DEPTH==16) scaledglprintf(0.005,0.005,_("2 - COLOR DEPTH: 16bit  "));
        if (COLOUR_DEPTH==24) scaledglprintf(0.005,0.005,_("2 - COLOR DEPTH: 24bit  "));
        if (COLOUR_DEPTH==32) scaledglprintf(0.005,0.005,_("2 - COLOR DEPTH: 32bit  "));
        glTranslatef(0,-1,0);
        if (fullscreen) scaledglprintf(0.005,0.005,_("3 - FULLSCREEN          "));
        else scaledglprintf(0.005,0.005,_("3 - WINDOWED            "));
        glTranslatef(0,-1,0);
        if (shadows==0) scaledglprintf(0.005,0.005,_("4 - SHADOWS: OFF        "));
        if (shadows==1) scaledglprintf(0.005,0.005,_("4 - SHADOWS: ON - DIAG  "));
        if (shadows==2) scaledglprintf(0.005,0.005,_("4 - SHADOWS: ON - VERT  "));
        glTranslatef(0,-1,0);
        if (detaillevel==0) scaledglprintf(0.005,0.005,_("5 - DETAIL: LOWEST      "));
        if (detaillevel==1) scaledglprintf(0.005,0.005,_("5 - DETAIL: LOW         "));
        if (detaillevel==2) scaledglprintf(0.005,0.005,_("5 - DETAIL: MEDIUM      "));
        if (detaillevel==3) scaledglprintf(0.005,0.005,_("5 - DETAIL: HIGH        "));
        if (detaillevel==4) scaledglprintf(0.005,0.005,_("5 - DETAIL: HIGHEST     "));
        glTranslatef(0,-1,0);
        if (sound) scaledglprintf(0.005,0.005,_("6 - SOUND: ON           "));
              else scaledglprintf(0.005,0.005,_("6 - SOUND: OFF          "));
        glTranslatef(0,-1,0);
        if (level==0) scaledglprintf(0.005,0.005,_("7 - LEVEL: EASY         "));
        if (level==1) scaledglprintf(0.005,0.005,_("7 - LEVEL: NORMAL       "));
        if (level==2) scaledglprintf(0.005,0.005,_("7 - LEVEL: HARD         "));
        if (level==3) scaledglprintf(0.005,0.005,_("7 - LEVEL: IMPOSSIBLE   "));
        glTranslatef(0,-1,0);
        if (show_radar) scaledglprintf(0.005,0.005,_("8 - RADAR: ON           "));
                   else scaledglprintf(0.005,0.005,_("8 - RADAR: OFF          "));
        glTranslatef(0,-1,0);
        scaledglprintf(0.005,0.005,_("9 - BACK                "));
        break;
    case 7:
        {
            char tmp[256];

            glColor3f(0.5,0.5,1.0);
            glTranslatef(0,5,0);
            scaledglprintf(0.005,0.005,"REDEFINE KEYBOARD");
            glTranslatef(0,-2,0);
            if (mainmenu_substatus!=0) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR UP: %s"),strupr(SDL_GetKeyName((SDLKey)up_key)));
            scaledglprintf(0.005,0.005,tmp);
            glTranslatef(0,-1,0);
            if (mainmenu_substatus!=1) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR DOWN: %s"),strupr(SDL_GetKeyName((SDLKey)down_key)));
            scaledglprintf(0.005,0.005,tmp);
            glTranslatef(0,-1,0);
            if (mainmenu_substatus!=2) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR LEFT: %s"),strupr(SDL_GetKeyName((SDLKey)left_key)));
            scaledglprintf(0.005,0.005,tmp);
            glTranslatef(0,-1,0);
            if (mainmenu_substatus!=3) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR RIGHT: %s"),strupr(SDL_GetKeyName((SDLKey)right_key)));
            scaledglprintf(0.005,0.005,tmp);
            glTranslatef(0,-1,0);
            if (mainmenu_substatus!=4) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR FIRE: %s"),strupr(SDL_GetKeyName((SDLKey)fire_key)));
            scaledglprintf(0.005,0.005,tmp);

            glTranslatef(0,-1,0);
            if (mainmenu_substatus!=5) glColor3f(0.5,0.5,1.0);
                                  else glColor3f(1.0,0.0,0.0);
            sprintf(tmp,_("PRESS A KEY FOR PAUSE/MENU: %s"),strupr(SDL_GetKeyName((SDLKey)pause_key)));
            scaledglprintf(0.005,0.005,tmp);

            glColor3f(0.5,0.5,1.0);
            glTranslatef(0,-2,0);
            scaledglprintf(0.005,0.005,_("PG.UP/PG.DOWN CHANGE THE ZOOM"));

            if (mainmenu_substatus>5) {
                glColor3f(1,1,1);
                glTranslatef(0,-2,0);
                scaledglprintf(0.005,0.005,_("PRESS ANY KEY TO RETURN TO MAIN MENU"));
            } /* if */
        }
        break;
    } /* switch */

    SDL_GL_SwapBuffers();
} /* NETHER::draw */
Ejemplo n.º 9
0
int main(int argc, char **argv)
{
	char	revision[16];
	char	error[512];
	char	*p,str[256],fname[256],ext,not[MAX_NOTS][9];
	uchar	*datbuf,*ixbbuf;
	int 	i,j,file,dirnum,libnum,desc_off,lines,nots=0
			,omode=O_WRONLY|O_CREAT|O_TRUNC;
	ulong	l,m,n,cdt,misc=0,total_cdt=0,total_files=0,dir_files,datbuflen;
	time32_t uld,dld,now;
	long	max_age=0;
	FILE	*in,*out=NULL;

	sscanf("$Revision$", "%*s %s", revision);

	fprintf(stderr,"\nFILELIST v%s-%s (rev %s) - Generate Synchronet File "
		"Directory Lists\n"
		,FILELIST_VER
		,PLATFORM_DESC
		,revision
		);

	if(argc<2 
		|| strcmp(argv[1],"-?")==0 
		|| strcmp(argv[1],"-help")==0 
		|| strcmp(argv[1],"--help")==0 
		|| strcmp(argv[1],"/?")==0
		) {
		printf("\n   usage: FILELIST <dir_code or - for ALL> [switches] [outfile]\n");
		printf("\n");
		printf("switches: -lib name All directories of specified library\n");
		printf("          -not code Exclude specific directory\n");
		printf("          -new days Include only new files in listing (days since upload)\n");
		printf("          -cat      Concatenate to existing outfile\n");
		printf("          -pad      Pad filename with spaces\n");
		printf("          -hdr      Include directory headers\n");
		printf("          -cdt      Include credit value\n");
		printf("          -tot      Include credit totals\n");
		printf("          -uln      Include uploader's name\n");
		printf("          -uld      Include upload date\n");
		printf("          -dfd      Include DOS file date\n");
		printf("          -dld      Include download date\n");
		printf("          -dls      Include total downloads\n");
		printf("          -nod      Exclude normal descriptions\n");
		printf("          -noe      Exclude normal descriptions, if extended "
			"exists\n");
		printf("          -ext      Include extended descriptions\n");
		printf("          -jst      Justify extended descriptions under normal\n");
		printf("          -+        Include extended description indicator (+)\n");
		printf("          --        Include offline file indicator (-)\n");
		printf("          -*        Short-hand for -pad -hdr -cdt -+ --\n");
		exit(0); }

	p=getenv("SBBSCTRL");
	if(p==NULL) {
		printf("\nSBBSCTRL environment variable not set.\n");
		printf("\nExample: SET SBBSCTRL=/sbbs/ctrl\n");
		exit(1); 
	}

	now=time32(NULL);

	memset(&scfg,0,sizeof(scfg));
	scfg.size=sizeof(scfg);
	SAFECOPY(scfg.ctrl_dir,p);

	if(chdir(scfg.ctrl_dir)!=0)
		fprintf(stderr,"!ERROR changing directory to: %s", scfg.ctrl_dir);

	printf("\nLoading configuration files from %s\n",scfg.ctrl_dir);
	if(!load_cfg(&scfg,NULL,TRUE,error)) {
		fprintf(stderr,"!ERROR loading configuration files: %s\n",error);
		exit(1);
	}
	SAFECOPY(scfg.temp_dir,"../temp");
	prep_dir(scfg.ctrl_dir, scfg.temp_dir, sizeof(scfg.temp_dir));

	dirnum=libnum=-1;
	if(argv[1][0]=='*' || strcmp(argv[1],"-")==0)
		misc|=ALL;
	else if(argv[1][0]!='-') {
		strupr(argv[1]);
		for(i=0;i<scfg.total_dirs;i++)
			if(!stricmp(argv[1],scfg.dir[i]->code))
				break;
		if(i>=scfg.total_dirs) {
			printf("\nDirectory code '%s' not found.\n",argv[1]);
			exit(1); }
		dirnum=i; }
	for(i=1;i<argc;i++) {
		if(!stricmp(argv[i],"-lib")) {
			if(dirnum!=-1) {
				printf("\nBoth directory code and -lib parameters were used.\n");
				exit(1); }
			i++;
			if(i>=argc) {
				printf("\nLibrary short name must follow -lib parameter.\n");
				exit(1); }
			strupr(argv[i]);
			for(j=0;j<scfg.total_libs;j++)
				if(!stricmp(scfg.lib[j]->sname,argv[i]))
					break;
			if(j>=scfg.total_libs) {
				printf("\nLibrary short name '%s' not found.\n",argv[i]);
				exit(1); }
			libnum=j; }
		else if(!stricmp(argv[i],"-not")) {
			if(nots>=MAX_NOTS) {
				printf("\nMaximum number of -not options (%u) exceeded.\n"
					,MAX_NOTS);
				exit(1); }
			i++;
			if(i>=argc) {
				printf("\nDirectory internal code must follow -not parameter.\n");
				exit(1); }
			sprintf(not[nots++],"%.8s",argv[i]); }
		else if(!stricmp(argv[i],"-all")) {
			if(dirnum!=-1) {
				printf("\nBoth directory code and -all parameters were used.\n");
				exit(1); }
			if(libnum!=-1) {
				printf("\nBoth library name and -all parameters were used.\n");
				exit(1); }
			misc|=ALL; }
		else if(!stricmp(argv[i],"-new")) {
			i++;
			if(i>=argc) {
				printf("\nDays since upload must follow -new parameter.\n");
				exit(1); 
			}
			max_age=strtol(argv[i],NULL,0);
		}
		else if(!stricmp(argv[i],"-pad"))
			misc|=PAD;
		else if(!stricmp(argv[i],"-cat"))
			omode=O_WRONLY|O_CREAT|O_APPEND;
		else if(!stricmp(argv[i],"-hdr"))
			misc|=HDR;
		else if(!stricmp(argv[i],"-cdt"))
			misc|=CDT_;
		else if(!stricmp(argv[i],"-tot"))
			misc|=TOT;
		else if(!stricmp(argv[i],"-ext"))
			misc|=EXT;
		else if(!stricmp(argv[i],"-uln"))
			misc|=ULN;
		else if(!stricmp(argv[i],"-uld"))
			misc|=ULD;
		else if(!stricmp(argv[i],"-dld"))
			misc|=DLD;
		else if(!stricmp(argv[i],"-dfd"))
			misc|=DFD;
		else if(!stricmp(argv[i],"-dls"))
			misc|=DLS;
		else if(!stricmp(argv[i],"-nod"))
			misc|=NOD;
		else if(!stricmp(argv[i],"-jst"))
			misc|=(EXT|JST);
		else if(!stricmp(argv[i],"-noe"))
			misc|=(EXT|NOE);
		else if(!stricmp(argv[i],"-+"))
			misc|=PLUS;
		else if(!stricmp(argv[i],"--"))
			misc|=MINUS;
		else if(!stricmp(argv[i],"-*"))
			misc|=(HDR|PAD|CDT_|PLUS|MINUS);

		else if(i!=1) {
			if(argv[i][0]=='*' || strcmp(argv[i],"-")==0) {
				misc|=AUTO;
				continue; }
			if((j=nopen(argv[i],omode))==-1) {
				printf("\nError opening/creating %s for output.\n",argv[i]);
				exit(1); }
			out=fdopen(j,"wb"); } }

	if(!out && !(misc&AUTO)) {
		printf("\nOutput file not specified, using FILES.BBS in each "
			"directory.\n");
		misc|=AUTO; }

	for(i=0;i<scfg.total_dirs;i++) {
		dir_files=0;
		if(!(misc&ALL) && i!=dirnum && scfg.dir[i]->lib!=libnum)
			continue;
		for(j=0;j<nots;j++)
			if(!stricmp(not[j],scfg.dir[i]->code))
				break;
		if(j<nots)
			continue;
		if(misc&AUTO && scfg.dir[i]->seqdev) 	/* CD-ROM */
			continue;
		printf("\n%-*s %s",LEN_GSNAME,scfg.lib[scfg.dir[i]->lib]->sname,scfg.dir[i]->lname);
		sprintf(str,"%s%s.ixb",scfg.dir[i]->data_dir,scfg.dir[i]->code);
		if((file=nopen(str,O_RDONLY))==-1)
			continue;
		l=filelength(file);
		if(misc&AUTO) {
			sprintf(str,"%sFILES.BBS",scfg.dir[i]->path);
			if((j=nopen(str,omode))==-1) {
				printf("\nError opening/creating %s for output.\n",str);
				exit(1); }
			out=fdopen(j,"wb"); }
		if(misc&HDR) {
			sprintf(fname,"%-*s      %-*s       Files: %4lu"
				,LEN_GSNAME,scfg.lib[scfg.dir[i]->lib]->sname
				,LEN_SLNAME,scfg.dir[i]->lname,l/F_IXBSIZE);
			fprintf(out,"%s\r\n",fname);
			memset(fname,'-',strlen(fname));
			fprintf(out,"%s\r\n",fname); }
		if(!l) {
			close(file);
			if(misc&AUTO) fclose(out);
			continue; }
		if((ixbbuf=(uchar *)malloc(l))==NULL) {
			close(file);
			if(misc&AUTO) fclose(out);
			printf("\7ERR_ALLOC %s %lu\n",str,l);
			continue; }
		if(read(file,ixbbuf,l)!=(int)l) {
			close(file);
			if(misc&AUTO) fclose(out);
			printf("\7ERR_READ %s %lu\n",str,l);
			free((char *)ixbbuf);
			continue; }
		close(file);
		sprintf(str,"%s%s.dat",scfg.dir[i]->data_dir,scfg.dir[i]->code);
		if((file=nopen(str,O_RDONLY))==-1) {
			printf("\7ERR_OPEN %s %u\n",str,O_RDONLY);
			free((char *)ixbbuf);
			if(misc&AUTO) fclose(out);
			continue; }
		datbuflen=filelength(file);
		if((datbuf=malloc(datbuflen))==NULL) {
			close(file);
			printf("\7ERR_ALLOC %s %lu\n",str,datbuflen);
			free((char *)ixbbuf);
			if(misc&AUTO) fclose(out);
			continue; }
		if(read(file,datbuf,datbuflen)!=(int)datbuflen) {
			close(file);
			printf("\7ERR_READ %s %lu\n",str,datbuflen);
			free((char *)datbuf);
			free((char *)ixbbuf);
			if(misc&AUTO) fclose(out);
			continue; }
		close(file);
		m=0L;
		while(m<l && !ferror(out)) {
			for(j=0;j<12 && m<l;j++)
				if(j==8)
					str[j]=ixbbuf[m]>' ' ? '.' : ' ';
				else
					str[j]=ixbbuf[m++]; /* Turns FILENAMEEXT into FILENAME.EXT */
			str[j]=0;
			unpadfname(str,fname);
			n=ixbbuf[m]|((long)ixbbuf[m+1]<<8)|((long)ixbbuf[m+2]<<16);
			uld=(ixbbuf[m+3]|((long)ixbbuf[m+4]<<8)|((long)ixbbuf[m+5]<<16)
				|((long)ixbbuf[m+6]<<24));
			dld=(ixbbuf[m+7]|((long)ixbbuf[m+8]<<8)|((long)ixbbuf[m+9]<<16)
				|((long)ixbbuf[m+10]<<24));
			m+=11;

			if(n>=datbuflen 							/* index out of bounds */
				|| datbuf[n+F_DESC+LEN_FDESC]!=CR) {	/* corrupted data */
				fprintf(stderr,"\n\7%s%s is corrupted!\n"
					,scfg.dir[i]->data_dir,scfg.dir[i]->code);
				exit(-1); }
			
			if(max_age && ((now - uld) / (24*60*60) > max_age))
				continue;

			fprintf(out,"%-12.12s",misc&PAD ? str : fname);

			total_files++;
			dir_files++;

			if(misc&PLUS && datbuf[n+F_MISC]!=ETX
				&& (datbuf[n+F_MISC]-' ')&FM_EXTDESC)
				fputc('+',out);
			else
				fputc(' ',out);

			desc_off=12;
			if(misc&(CDT_|TOT)) {
				getrec((char *)&datbuf[n],F_CDT,LEN_FCDT,str);
				cdt=atol(str);
				total_cdt+=cdt;
				if(misc&CDT_) {
					fprintf(out,"%7lu",cdt);
					desc_off+=7; } }

			if(misc&MINUS) {
				sprintf(str,"%s%s",scfg.dir[i]->path,fname);
				if(!fexistcase(str))
					fputc('-',out);
				else
					fputc(' ',out); }
			else
				fputc(' ',out);
			desc_off++;

			if(misc&DFD) {
				sprintf(str,"%s%s",scfg.dir[i]->path,fname);
				fprintf(out,"%s ",unixtodstr(&scfg,(time32_t)fdate(str),str));
				desc_off+=9; }

			if(misc&ULD) {
				fprintf(out,"%s ",unixtodstr(&scfg,uld,str));
				desc_off+=9; }

			if(misc&ULN) {
				getrec((char *)&datbuf[n],F_ULER,25,str);
				fprintf(out,"%-25s ",str);
				desc_off+=26; }

			if(misc&DLD) {
				fprintf(out,"%s ",unixtodstr(&scfg,dld,str));
				desc_off+=9; }

			if(misc&DLS) {
				getrec((char *)&datbuf[n],F_TIMESDLED,5,str);
				j=atoi(str);
				fprintf(out,"%5u ",j);
				desc_off+=6; }

			if(datbuf[n+F_MISC]!=ETX && (datbuf[n+F_MISC]-' ')&FM_EXTDESC)
				ext=1;	/* extended description exists */
			else
				ext=0;	/* it doesn't */

			if(!(misc&NOD) && !(misc&NOE && ext)) {
				getrec((char *)&datbuf[n],F_DESC,LEN_FDESC,str);
				fprintf(out,"%s",str); }

			if(misc&EXT && ext) {							/* Print ext desc */

				sprintf(str,"%s%s.exb",scfg.dir[i]->data_dir,scfg.dir[i]->code);
				if(!fexist(str))
					continue;
				if((j=nopen(str,O_RDONLY))==-1) {
					printf("\7ERR_OPEN %s %u\n",str,O_RDONLY);
					continue; }
				if((in=fdopen(j,"rb"))==NULL) {
					close(j);
					continue; }
				fseek(in,(n/F_LEN)*512L,SEEK_SET);
				lines=0;
				if(!(misc&NOE)) {
					fprintf(out,"\r\n");
					lines++; }
				while(!feof(in) && !ferror(in)
					&& ftell(in)<(long)((n/F_LEN)+1)*512L) {
					if(!fgets(str,128,in) || !str[0])
						break;
					stripctrlz(str);
					if(lines) {
						if(misc&JST)
							fprintf(out,"%*s",desc_off,"");
						fputc(' ',out);				/* indent one character */ }
					fprintf(out,"%s",str);
					lines++; }
				fclose(in); }
			fprintf(out,"\r\n"); }
		free((char *)datbuf);
		free((char *)ixbbuf);
		if(dir_files)
			fprintf(out,"\r\n"); /* blank line at end of dir */
		if(misc&AUTO) fclose(out); }

	if(misc&TOT && !(misc&AUTO))
		fprintf(out,"TOTALS\n------\n%lu credits/bytes in %lu files.\r\n"
			,total_cdt,total_files);
	printf("\nDone.\n");
	return(0);
}
Ejemplo n.º 10
0
bool WGetEditWindowID( HWND dlg, char **symbol, uint_16 *id,
                       WRHashTable *symbol_table, bool combo_change )
{
    int_32      val;
    char        *ep;
    WRHashValue hv;
    WRHashEntry *new_entry;
    bool        dup;

    if( dlg == (HWND)NULL ) {
        return( FALSE );
    }

    if( combo_change ) {
        *symbol = WGetStrFromComboLBox( GetDlgItem( dlg, IDM_ACCEDCMDID ), -1 );
    } else {
        *symbol = WGetStrFromEdit( GetDlgItem( dlg, IDM_ACCEDCMDID ), NULL );
    }

    if( *symbol == NULL ) {
        return( FALSE );
    }

    if( **symbol == '\0' ) {
        *symbol = WGetStrFromEdit( GetDlgItem( dlg, IDM_ACCEDCMDNUM ), NULL );
    }

    if( *symbol == NULL ) {
        return( FALSE );
    }

    strupr( *symbol );

    // check if the string has a numeric representation
    val = (int_32)strtol( *symbol, &ep, 0 );
    if( *ep != '\0' ) {
        // the string did not have a numeric representation
        // so let's look it up in the hash table
        if( WRLookupName( symbol_table, *symbol, &hv ) ) {
            *id = (uint_16)hv;
        } else {
            dup = false;
            new_entry = WRAddDefHashEntry( symbol_table, *symbol, &dup );
            if( new_entry != NULL ) {
                *id = (uint_16)new_entry->value;
                if( !dup ) {
                    SendDlgItemMessage( dlg, IDM_ACCEDCMDID, CB_ADDSTRING,
                                        0, (LPARAM)(LPSTR)new_entry->name );
                    SendDlgItemMessage( dlg, IDM_ACCEDCMDID, CB_SETITEMDATA,
                                        0, (LPARAM)new_entry );
                }
            } else {
                *id = 0;
                WRMemFree( *symbol );
                *symbol = NULL;
                return( FALSE );
            }
        }
    } else {
        // the string did have a numeric representation
        *id = (uint_16)val;
        WRMemFree( *symbol );
        *symbol = NULL;
    }

    return( TRUE );
}
Ejemplo n.º 11
0
bytes_t HGE_CALL HGE_Impl::Resource_Load(const char *filename, uint32_t *size)
{
    static char *res_err = "Can't load resource: %s";

    //resource_packs_item_t *resItem = m_resources;
    char szName[_MAX_PATH];
    char szZipName[_MAX_PATH];
    unzFile zip;
    unz_file_info file_info;
    int done, i;
    void * ptr;
    HANDLE hF;

    if (filename[0] == '\\' || filename[0] == '/' || filename[1] == ':')
        goto _fromfile; // skip absolute paths

    // Load from pack

    strcpy(szName, filename);
    strupr(szName);
    for (i = 0; szName[i]; i++)
    {
        if (szName[i] == '/')
            szName[i] = '\\';
    }

    //while (resItem)
    // TODO: optimize this reopening shit out
    for( auto itr = m_resources.begin(); itr != m_resources.end(); ++itr )
    {
        resource_packs_item_t & resItem = itr->second;

        zip = unzOpen(resItem.filename.c_str());
        done = unzGoToFirstFile(zip);
        while (done == UNZ_OK)
        {
            unzGetCurrentFileInfo(zip, &file_info, szZipName, sizeof(szZipName), NULL, 0, NULL, 0);
            strupr(szZipName);
            for (i = 0; szZipName[i]; i++)
            {
                if (szZipName[i] == '/')
                    szZipName[i] = '\\';
            }
            if (!strcmp(szName, szZipName))
            {
                if (unzOpenCurrentFilePassword( zip, resItem.password.empty()
                                                ? resItem.password.c_str()
                                                : nullptr ) != UNZ_OK)
                {
                    unzClose(zip);
                    sprintf(szName, res_err, filename);
                    _PostError(szName);
                    return nullptr;
                }

                ptr = malloc(file_info.uncompressed_size);
                if (!ptr)
                {
                    unzCloseCurrentFile(zip);
                    unzClose(zip);
                    sprintf(szName, res_err, filename);
                    _PostError(szName);
                    return nullptr;
                }

                if (unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0)
                {
                    unzCloseCurrentFile(zip);
                    unzClose(zip);
                    free(ptr);
                    sprintf(szName, res_err, filename);
                    _PostError(szName);
                    return nullptr;
                }
                unzCloseCurrentFile(zip);
                unzClose(zip);
                if (size)
                    *size = file_info.uncompressed_size;
                return bytes_t( (char*)ptr );
            }

            done = unzGoToNextFile(zip);
        }

        unzClose(zip);
        //resItem = resItem->next;
    }

    // Load from file
_fromfile:

    hF = CreateFile(Resource_MakePath(filename), GENERIC_READ, FILE_SHARE_READ, NULL,
                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
    if (hF == INVALID_HANDLE_VALUE)
    {
        sprintf(szName, res_err, filename);
        _PostError(szName);
        return nullptr;
    }
    file_info.uncompressed_size = GetFileSize(hF, NULL);
    ptr = malloc(file_info.uncompressed_size);
    if (!ptr)
    {
        CloseHandle(hF);
        sprintf(szName, res_err, filename);
        _PostError(szName);
        return nullptr;
    }
    if (ReadFile(hF, ptr, file_info.uncompressed_size, &file_info.uncompressed_size, NULL ) == 0)
    {
        CloseHandle(hF);
        free(ptr);
        sprintf(szName, res_err, filename);
        _PostError(szName);
        return nullptr;
    }

    CloseHandle(hF);
    if (size)
        *size = file_info.uncompressed_size;
    return bytes_t( (char*)ptr);
}
Ejemplo n.º 12
0
BOOL CDirTreeCtrl::SetSelPath (LPCTSTR strPath)
{
	// Setting the Selection in the Tree
	HTREEITEM hParent  = TVI_ROOT;
	int       iLen    = strlen(strPath) + 2;
	char*     pszPath = new char[iLen];
	char*     pPath   = pszPath;
	BOOL      bRet    = FALSE;
    
	if ( !IsValidPath( strPath ) )
	{
		delete [] pszPath; // this must be added 29.03.99
		return FALSE;
	}
		
	strcpy( pszPath, strPath );
	strupr( pszPath );
	
	if ( pszPath[strlen(pszPath)-1] != '\\' )
		strcat( pszPath, "\\" );
    
	int iLen2 = strlen( pszPath );
	
	for (WORD i = 0; i < iLen2; i++ )
	{
		if ( pszPath[i] == '\\' )
		{
			SetRedraw( FALSE );
			pszPath[i] = '\0';
			hParent = SearchSiblingItem( hParent, pPath );
			if ( !hParent )  // Not found!
				break;
			else
			{				
				// Info:
				// the notification OnItemExpanded 
				// will not called every time 
				// after the call Expand. 
				// You must call Expand with TVE_COLLAPSE | TVE_COLLAPSERESET
				// to Reset the TVIS_EXPANDEDONCE Flag
				
				UINT uState;
				uState = GetItemState( hParent, TVIS_EXPANDEDONCE );
				if ( uState )
				{
					Expand( hParent, TVE_EXPAND );
					Expand( hParent, TVE_COLLAPSE | TVE_COLLAPSERESET );
					InsertItem("", hParent ); // insert a blank child-item
					Expand( hParent, TVE_EXPAND ); // now, expand send a notification
				}
				else
					Expand( hParent, TVE_EXPAND );
			}
			pPath += strlen(pPath) + 1;
		}
	}

	delete [] pszPath;
	
	if ( hParent ) // Ok the last subpath was found
	{		
		SelectItem( hParent ); // select the last expanded item
		bRet = TRUE;
	}
	else
	{
		bRet = FALSE;
	}
	
	SetRedraw( TRUE );

    return bRet;
}
Ejemplo n.º 13
0
void main ( BYTE argc, char *argv[] )
{
	int i=2 ;

  /*********** STARTUP AND PARAMETER PARSING **************/

	/* Opening strings */
	printf ("BOOKSHLF %s - FreeDOS Book Shelf manager\n", VerS);
	puts ("Copyright Aitor SANTAMARIA MERINO under the GNU GPL 2.0\n");

	/* Discard FastHelp */

	if ( (argc==1) ||
	     ( (argc==2) && (!strcmp(argv[1],"/?")) ) )
	     FastHelp ();

	/* Determine command (argv[1]) */

	if (!strcmp (strupr(argv[1]),"LIST") )
		curcommand = CM_List;
	else if (!strcmp (argv[1],"ADD"))
		curcommand = CM_Add;
	else if (!strcmp (argv[1],"DEL"))
		curcommand = CM_Del;
	else
		CriticalError (SC_UnknownCommand, "");

	/* Get the book name (ADD/DEL) */
	if ( (curcommand==CM_Add) || (curcommand==CM_Del) )
	{
		if (argc<3) CriticalError (SC_WrongNParams, "");
		strncpy (BookName, argv[i++], MaxLine);
	}

	/* More arguments? */
	if (argc > (i+1)) CriticalError (SC_WrongNParams, "");
	if (argc == (i+1))
		strncpy (finName, argv[i], 255);


  /*********** OPENING FILES **************/

	/*  Try to open the source HTML file */
	i=1;	/* Flag meaning: 2=no finName was specified, 1=was specified */
	if (!finName[0])
	{
		i++;
		strcpy (finName, "..\\HELP\\INDEX.HTM");
//		strcpy (finName, "INDEX.HTM");
// for easy testings
	}

	while (i--)
		if ((fin = fopen (finName,"rt"))!=NULL) i=0;
		else
		   if (i) {
			strcpy (foutName, getenv ("HELPPATH"));
			if (!foutName[0]) CriticalError (SC_CantOpenSource, finName);
			strcat (foutName, "\\INDEX.HTM");
			strcpy (finName, foutName);
		   }
		   else CriticalError (SC_CantOpenSource, finName);


	/* Add extension BI if not present */
	if ( curcommand==CM_Add )
	{
		for ( i = strlen(BookName)-1; (i>=0) && (BookName[i]!='\\') && (BookName[i]!='.'); i--);
		if (! ((i>=0) && (BookName[i]=='.')) )
			strcat (BookName, ".BI");

		/* Open book index */
		if ((fbook = fopen (BookName,"rt"))==NULL)
			CriticalError (SC_CantOpenBI, BookName);
	}

	/* Compose the target file name .$$$ and try to open it (ADD/DEL) */
	if ( (curcommand==CM_Add) || (curcommand==CM_Del) )
	{
		for ( i=strlen(finName)-1; (i>=0) && (finName[i]!='\\')
						   && (finName[i]!='.')         ; i--);
		if ( (i<0) || ( (i>=0) && (finName[i]=='\\') ) )
			i=strlen(finName);

		strncpy (foutName, finName, i);
		strcat  (foutName, ".$$$");

		if ((fout = fopen (foutName,"wt"))==NULL)
			CriticalError (SC_CantOpenTarget, foutName);
	}

  /*********** MAIN WORK **************/

	/* Find <!--BOOKSHELF-->*/
	do {
		fgets (line, MaxLine, fin);
		if ( (curcommand==CM_Add) || (curcommand==CM_Del) )
			fputs (line, fout);
		NoSpaces();
	} while ( strcmp(line,"<!--BOOKSHELF-->") &&
		    !feof (fin)	);
	if (feof(fin)) CriticalError (SC_NoBookhelpFile, finName);

	/* Main loop */
	switch ( curcommand )
	{
		case CM_List: List();
				  break;
		case CM_Add:  Add();
				  break;
		case CM_Del:  Del();
	}

  /*********** CLOSING TASKS **************/

	/* Close files */
	switch ( curcommand )
	{
	   case CM_Add:
		fclose (fbook);

	   case CM_Del:
		while (!feof(fin))
		{
			fgets (line, MaxLine, fin);
			if (feof(fin)) break;
			fputs (line, fout);
		}
		fclose (fout);

	   case CM_List:
		fclose (fin);
	}

	/* File renaming stuff */
	if ( (curcommand==CM_Add) || (curcommand==CM_Del) )
	{
		/* create the back name */
		strncpy (fbackName, finName, 255);
		if ( (strlen(fbackName)>4) &&
		     (fbackName[strlen(fbackName)-4]=='.') )
			fbackName[strlen(fbackName)-4]=0;
		strcat (fbackName,".BAK");

		/* File mangling */
		if (remove(fbackName)) CriticalError (SC_CantRemoveFin, finName);
		if (rename(finName,fbackName)) CriticalError (SC_CantRemoveFin, finName);
		if (rename(foutName,finName)) CriticalError (SC_CantRemoveFin, finName);

		if (curcommand==CM_Add) puts ("Book successfully added.");
		else		     	      puts ("Book successfully removed.");
	}

}
Ejemplo n.º 14
0
void Add ( void )
{
	char tag[MaxLine]= "<!--BOOK=";
	char stout[255] = "";
	BOOL Updates = FALSE;

	/* Set the book header */
	for (; (strlen(BookName)>0) && (BookName[strlen(BookName)-1]!='.');
		 BookName[strlen(BookName)-1]=0);
	BookName[strlen(BookName)-1]=0;

	/* Get the tag name */
	strcat (tag,BookName);
	strcat (tag,"-->");
	strupr (tag);

	/* Pass all earlier */
	while (TRUE) {
		fgets  (line, MaxLine, fin);

		if (feof(fin)) CriticalError (SC_BooksCorrupted, "");
		strcpy (stout, line);
		NoSpaces();

		if (!strcmp(line,"<!--/BOOKSHELF-->")) break;
		if (strcmp(line,tag)>=0) break;

		strcat (line,"\n");
		fputs (line, fout);
		do {
			fgets (line, MaxLine,fin);
			fputs (line, fout);
			NoSpaces();
		} while (strcmp(line,"<!--/BOOK-->"));

	}
	   /* In all exits of this loop through here, stout is pending to be put */

	/* if present, update, that is, ignore previous book */
	if (!strcmp(line,tag))  {
		Updates = TRUE;		/* flag to say that we don't have to */
						/* append the saved line */
		do {
			fgets (line, MaxLine,fin);
			NoSpaces();
		} while (strcmp(line,"<!--/BOOK-->"));
	}

	/* Insert the book */
	fprintf (fout, "%s\n", tag);

	/* Transfer contents */
	while (TRUE) {
		fgets (line, MaxLine, fbook);
		if feof(fbook) break;
		fputs (line, fout);
	}

	/* Set the book end */
	fputs ("<!--/BOOK-->\n", fout);

	if (!Updates) fputs (stout, fout);
}
Ejemplo n.º 15
0
int		GetScriptInfo(char *name)
{
    FILE		*fp;
    char		buffer[256];
    char		tempbuff[256];
    char		delims[] = {" \t,\n"};

    printf("Opening script file %s.\n", name);

    if (fp = fopen(name, "r"))
    {
        while(fgets(buffer, 256, fp))
        {
            if (strncmp(buffer, "//", 2) && strncmp(buffer, "\n", 1))
            {
                strupr(buffer);
                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "OUTPUT") == 0)
                {
                    strcpy(out.name, strtok(NULL, delims));
                    strlwr(out.name);
                }

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "SOURCEDIR") == 0)
                {
                    strcpy(tempbuff, strtok(NULL, delims));
                    strcpy(sourcedir, ExpandPathAndArchive(tempbuff));
                }

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "DOSORT") == 0)
                    dosort = 1;

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "XCHARSIZE") == 0)
                    xcharsize = strtol(strtok(NULL, delims), NULL, 0);

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "YCHARSIZE") == 0)
                    ycharsize = strtol(strtok(NULL, delims), NULL, 0);

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "OUTSCRIPT") == 0)
                {
                    strcpy(outscript, strtok(NULL, delims));
                    strlwr(outscript);
                }

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "OUTUSAGE") == 0)
                    strcpy(outusage, strtok(NULL, delims));

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "POS") == 0)
                {
                    out.w = strtol(strtok(NULL, delims), NULL, 0);
                    out.h = strtol(strtok(NULL, delims), NULL, 0);
                }

                strcpy(tempbuff, buffer);
                if (strcmp(strtok(tempbuff, delims), "FILE") == 0)
                {
                    strcpy(in[filenum].name, strtok(NULL, delims));
                    in[filenum].x = strtol(strtok(NULL, delims), NULL, 0);
                    in[filenum].y = strtol(strtok(NULL, delims), NULL, 0);
                    in[filenum].col = strtol(strtok(NULL, delims), NULL, 0);
                    filenum++;
                }
            }
        }
        fclose(fp);
        return(true);
    }
    else
    {
        printf("ERROR : Could not open script file.\n");
        return(false);
    }
}
Ejemplo n.º 16
0
const char *inifile(const char *argv0x, const char *inifilex)
{
    char *argv0 = (char *)argv0x;
    char *inifile = (char *)inifilex;   // do const-correct later
    char *path;         // need path for @P macro
    char *filename;
    OutBuffer buf;
    int i;
    int k;
    int envsection = 0;

#if LOG
    printf("inifile(argv0 = '%s', inifile = '%s')\n", argv0, inifile);
#endif
    if (FileName::absolute(inifile))
    {
        filename = inifile;
    }
    else
    {
        /* Look for inifile in the following sequence of places:
         *      o current directory
         *      o home directory
         *      o directory off of argv0
         *      o /etc/
         */
        if (FileName::exists(inifile))
        {
            filename = inifile;
        }
        else
        {
            filename = FileName::combine(getenv("HOME"), inifile);
            if (!FileName::exists(filename))
            {
#if _WIN32 // This fix by Tim Matthews
                char resolved_name[MAX_PATH + 1];
                if(GetModuleFileName(NULL, resolved_name, MAX_PATH + 1) && FileName::exists(resolved_name))
                {
                        filename = (char *)FileName::replaceName(resolved_name, inifile);
                        if(FileName::exists(filename))
                                goto Ldone;
                }
#endif
                filename = (char *)FileName::replaceName(argv0, inifile);
                if (!FileName::exists(filename))
                {
#if linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4
#if __GLIBC__ || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4   // This fix by Thomas Kuehne
                    /* argv0 might be a symbolic link,
                     * so try again looking past it to the real path
                     */
#if __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4
                    char resolved_name[PATH_MAX + 1];
                    char* real_argv0 = realpath(argv0, resolved_name);
#else
                    char* real_argv0 = realpath(argv0, NULL);
#endif
                    //printf("argv0 = %s, real_argv0 = %p\n", argv0, real_argv0);
                    if (real_argv0)
                    {
                        filename = (char *)FileName::replaceName(real_argv0, inifile);
#if linux
                        free(real_argv0);
#endif
                        if (FileName::exists(filename))
                            goto Ldone;
                    }
#else
#error use of glibc non-standard extension realpath(char*, NULL)
#endif
                    if (1){
                    // Search PATH for argv0
                    const char *p = getenv("PATH");
#if LOG
                    printf("\tPATH='%s'\n", p);
#endif
                    Array *paths = FileName::splitPath(p);
                    filename = FileName::searchPath(paths, argv0, 0);
                    if (!filename)
                        goto Letc;              // argv0 not found on path
                    filename = (char *)FileName::replaceName(filename, inifile);
                    if (FileName::exists(filename))
                        goto Ldone;
                    }
#endif

                    // Search /etc/ for inifile
                Letc:
                    filename = FileName::combine((char *)"/etc/", inifile);

                Ldone:
                    ;
                }
            }
        }
    }
    path = FileName::path(filename);
#if LOG
    printf("\tpath = '%s', filename = '%s'\n", path, filename);
#endif

    File file(filename);

    if (file.read())
        return filename;                        // error reading file

    // Parse into lines
    int eof = 0;
    for (i = 0; i < file.len && !eof; i++)
    {
        int linestart = i;

        for (; i < file.len; i++)
        {
            switch (file.buffer[i])
            {
                case '\r':
                    break;

                case '\n':
                    // Skip if it was preceded by '\r'
                    if (i && file.buffer[i - 1] == '\r')
                        goto Lskip;
                    break;

                case 0:
                case 0x1A:
                    eof = 1;
                    break;

                default:
                    continue;
            }
            break;
        }

        // The line is file.buffer[linestart..i]
        char *line;
        int len;
        char *p;
        char *pn;

        line = (char *)&file.buffer[linestart];
        len = i - linestart;

        buf.reset();

        // First, expand the macros.
        // Macros are bracketed by % characters.

        for (k = 0; k < len; k++)
        {
            if (line[k] == '%')
            {
                int j;

                for (j = k + 1; j < len; j++)
                {
                    if (line[j] == '%')
                    {
                        if (j - k == 3 && memicmp(&line[k + 1], "@P", 2) == 0)
                        {
                            // %@P% is special meaning the path to the .ini file
                            p = path;
                            if (!*p)
                                p = (char *)".";
                        }
                        else
                        {   int len = j - k;
                            char tmp[10];       // big enough most of the time

                            if (len <= sizeof(tmp))
                                p = tmp;
                            else
                                p = (char *)alloca(len);
                            len--;
                            memcpy(p, &line[k + 1], len);
                            p[len] = 0;
                            strupr(p);
                            p = getenv(p);
                            if (!p)
                                p = (char *)"";
                        }
                        buf.writestring(p);
                        k = j;
                        goto L1;
                    }
                }
            }
            buf.writeByte(line[k]);
         L1:
            ;
        }

        // Remove trailing spaces
        while (buf.offset && isspace(buf.data[buf.offset - 1]))
            buf.offset--;

        p = buf.toChars();

        // The expanded line is in p.
        // Now parse it for meaning.

        p = skipspace(p);
        switch (*p)
        {
            case ';':           // comment
            case 0:             // blank
                break;

            case '[':           // look for [Environment]
                p = skipspace(p + 1);
                for (pn = p; isalnum(*pn); pn++)
                    ;
                if (pn - p == 11 &&
                    memicmp(p, "Environment", 11) == 0 &&
                    *skipspace(pn) == ']'
                   )
                    envsection = 1;
                else
                    envsection = 0;
                break;

            default:
                if (envsection)
                {
                    pn = p;

                    // Convert name to upper case;
                    // remove spaces bracketing =
                    for (p = pn; *p; p++)
                    {   if (islower(*p))
                            *p &= ~0x20;
                        else if (isspace(*p))
                            memmove(p, p + 1, strlen(p));
                        else if (*p == '=')
                        {
                            p++;
                            while (isspace(*p))
                                memmove(p, p + 1, strlen(p));
                            break;
                        }
                    }

                    putenv(strdup(pn));
#if LOG
                    printf("\tputenv('%s')\n", pn);
                    //printf("getenv(\"TEST\") = '%s'\n",getenv("TEST"));
#endif
                }
                break;
        }

     Lskip:
        ;
    }
    return filename;
}
Ejemplo n.º 17
0
int makeconnect (char *mycall, char *conncall)
//**************************************************************************
//
//
//**************************************************************************
{
  lastfunc("makeconnect");
  unsigned int port;
  //unsigned int port_org;

  if (l2vorhanden)
  {
    strupr(conncall);
    strupr(mycall);
#ifdef _AX25K
#ifndef _AX25K_ONLY
    CRegEx reg;
    if (ax25k_isdefault() || reg.regex_match("ax.*:", conncall))
#endif
      return ax25k_connect(mycall, conncall);
#endif
#ifndef _AX25K_ONLY
    if (t->port)
    {
      trace(serious, "makeconn", "port busy");
      return NO;
    }
    for (port = 2; port < (unsigned) highestport; port++)
    {
  //    port_org = port;
  //    port = random_max(highestport-port_org)+port_org-1;
      if (portopen[port] == p_closed)
      {
        portopen[port] = p_linksetup;
        rxdafl[port] = rxcbuf[port] = 0;
        connport_tnc(port, mycall, conncall);
        while (portopen[port] == p_linksetup)
        {
          switch (linkstate_tnc(port))
          {
          case info_transfer:
          case rej_sent:
          case wait_ack:
            t->port = port;
            portopen[port] = p_connected;
            trace(report, "makeconn", "ok %s", conncall);
            break;
          case disconnected:
            portopen[port] = p_closed;
            trace(report, "makeconn", "fail %s", conncall);
            break;
          default:
            {
              wdelay(245);
              if (testabbruch())
              {
                portopen[port] = p_closed;
                discport_tnc(port);
                return NO;
              }
            }
          }
        }
        return (portopen[port] == p_connected);
      }
  //    port = port_org;
    }
    trace(report, "makeconn", "no port");
    return NO;
#endif
  }
  else
    return NO;
}
Ejemplo n.º 18
0
void EarthData::LoadCities()
{
    float startTime = GetHighResTime();

    m_cities.EmptyAndDelete();

    TextReader *cities = g_fileSystem->GetTextReader( "data/earth/cities.dat" );
    AppAssert( cities && cities->IsOpen() );
    
    int numCities = 0;
    
    while( cities->ReadLine() )
    {
        char *line = cities->GetRestOfLine();

        char name[256];
        char country[256];
        float latitude, longitude;
        int population;
        int capital;
        
        strncpy( name, line, 40 );
        for( int i = 39; i >= 0; --i )
        {
            if( name[i] != ' ' ) 
            {
                name[i+1] = '\x0';
                break;
            }
        }

        strncpy( country, line+41, 40 );
        for( int i = 39; i >= 0; --i )
        {
            if( country[i] != ' ' )
            {
                country[i+1] = '\x0';
                break;
            }
        }

        sscanf( line+82, "%f %f %d %d", &longitude, &latitude, &population, &capital );

        City *city = new City();
        city->m_name = strdup( strupr(name) );
        city->m_country = strdup( strupr(country) );
        city->m_longitude = Fixed::FromDouble(longitude);
        city->m_latitude = Fixed::FromDouble(latitude);
        city->m_population = population;
        city->m_capital = capital;         
        city->SetRadarRange( Fixed::FromDouble(sqrtf( sqrtf(city->m_population) ) / 4.0f) );

        m_cities.PutData( city );
        ++numCities;
    }
    
    delete cities;

    float totalTime = GetHighResTime() - startTime;
    AppDebugOut( "Parsing City data (%d cities) : %dms\n", numCities, int( totalTime * 1000.0f ) );
}
 void ParseParms( int argc, char *argv[] )
  {
    int     j = 1 ;
    char TempText[80];

    CallCount   = 1;
    Iterations  = 1;
    Delay       = 0; 

    while ( j < argc )  {
       if ( strchr ( "/-(", argv[j][0] ) ) { /* looks like an option  */
          argv[j] = strupr ( argv[j] );             
          switch ( argv[j][1] )  {
            case '?' :                          /* /?:HELP               */
            case 'H' :                          /* /H:                   */
              SayHelp();          
              break;            
          case 'I' :                         /* /I:iterations         */
             Iterations = atoi ( &argv[j][3] );
             if( ( Iterations < 0 ) || ( Iterations  > 32000 ) ) {
                sprintf(TempText,"Iterations out of range 0 used instead of %s",
                                                                     &argv[j][3]);
                Info(TempText);                                                         
                Iterations = 0;
             } else {
                sprintf(TempText,"Iterations changed to %s",&argv[j][3]);
                Info(TempText);                                                         
             } /* endif */
             Unattended = 1;
             break;
          case 'D' :                         /* /D:Delay              */
             Delay = atof ( &argv[j][3] );
             Delay = Delay * 400; /* Make it a reasonable value */
             break;
          case 'S' :                         /* /S:Server             */
             strcpy( EciBlock.eci_system_name, &argv[j][3]);
             sprintf(TempText,"Server Selected = %s",EciBlock.eci_system_name);
             Info(TempText);                                                         
             break;
          case 'U' :                         /* /U:UserID             */
             strcpy( EciBlock.eci_userid, &argv[j][3]);
             sprintf(TempText,"User ID Selected = %s",EciBlock.eci_userid);
             Info(TempText);                                                         
             break;
          case 'P' :                         /* /P:Password           */
             strcpy( EciBlock.eci_password, &argv[j][3]);
             sprintf(TempText,"Password Supplied = %s",EciBlock.eci_password);
             Info(TempText);                                                         
             break;
          default :
             sprintf(TempText,"Ignoring Parameter %s",&argv[j][0]);
             Info(TempText);                                                         
             break;
          } /* endswitch */
       }
     else
       {
         sprintf(TempText,"Parameters must begin with a /=");
         Info(TempText);                                                         
       }
     j++;
  } /* endwhile */
 
 }
Ejemplo n.º 20
0
void* HGE_CALL HGE_Impl::Resource_Load(const char* filename, uint32_t* size) {
    static char* res_err = "Can't load resource: %s";

    auto res_item = res_list_;
    char sz_name[_MAX_PATH];
    char sz_zip_name[_MAX_PATH];
    unz_file_info file_info;
    int i;
    void* ptr;

    if (filename[0] == '\\' || filename[0] == '/' || filename[1] == ':') {
        goto _fromfile; // skip absolute paths
    }

    // Load from pack

    strcpy(sz_name, filename);
    strupr(sz_name);
    for (i = 0; sz_name[i]; i++) {
        if (sz_name[i] == '/') {
            sz_name[i] = '\\';
        }
    }

    while (res_item) {
        const auto zip = unzOpen(res_item->filename);
        auto done = unzGoToFirstFile(zip);
        while (done == UNZ_OK) {
            unzGetCurrentFileInfo(zip, &file_info, sz_zip_name, sizeof(sz_zip_name), nullptr, 0,
                                  nullptr, 0);
            strupr(sz_zip_name);
            for (i = 0; sz_zip_name[i]; i++) {
                if (sz_zip_name[i] == '/') {
                    sz_zip_name[i] = '\\';
                }
            }
            if (!strcmp(sz_name, sz_zip_name)) {
                if (unzOpenCurrentFilePassword(zip, res_item->password[0] ? res_item->password : 0)
                    !=
                    UNZ_OK) {
                    unzClose(zip);
                    sprintf(sz_name, res_err, filename);
                    post_error(sz_name);
                    return nullptr;
                }

                ptr = malloc(file_info.uncompressed_size);
                if (!ptr) {
                    unzCloseCurrentFile(zip);
                    unzClose(zip);
                    sprintf(sz_name, res_err, filename);
                    post_error(sz_name);
                    return nullptr;
                }

                if (unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0) {
                    unzCloseCurrentFile(zip);
                    unzClose(zip);
                    free(ptr);
                    sprintf(sz_name, res_err, filename);
                    post_error(sz_name);
                    return nullptr;
                }
                unzCloseCurrentFile(zip);
                unzClose(zip);
                if (size) {
                    *size = file_info.uncompressed_size;
                }
                return ptr;
            }

            done = unzGoToNextFile(zip);
        }

        unzClose(zip);
        res_item = res_item->next;
    }

    // Load from file
_fromfile:
    const auto h_f = CreateFile(Resource_MakePath(filename), GENERIC_READ,
                                FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
                                nullptr);
    if (h_f == INVALID_HANDLE_VALUE) {
        sprintf(sz_name, res_err, filename);
        post_error(sz_name);
        return nullptr;
    }
    file_info.uncompressed_size = GetFileSize(h_f, nullptr);
    ptr = malloc(file_info.uncompressed_size);
    if (!ptr) {
        CloseHandle(h_f);
        sprintf(sz_name, res_err, filename);
        post_error(sz_name);
        return nullptr;
    }
    if (ReadFile(h_f, ptr, file_info.uncompressed_size, &file_info.uncompressed_size,
                 nullptr) == 0) {
        CloseHandle(h_f);
        free(ptr);
        sprintf(sz_name, res_err, filename);
        post_error(sz_name);
        return nullptr;
    }

    CloseHandle(h_f);
    if (size) {
        *size = file_info.uncompressed_size;
    }
    return ptr;
}
Ejemplo n.º 21
0
void convertEx(IFileIO *fio, const char *file, int width, int height)
{
    char bmpFile[260];
    char suffix[260] = "NV21";
    char *p = NULL;
    FILE *fp = NULL;
    FileIOData *fioData = NULL;
    YUV_FORMAT format = YUV_NV21;
    
    strcpy(bmpFile, file);
    p = strrchr(bmpFile, '.');
    if(p == NULL)
    {
        p = bmpFile;
    }
    else
    {
        strcpy(suffix, p+1);
    }
    strcat(p, ".bmp");
    fp = fopen(bmpFile, "rb");
    if(fp != NULL)
    {
        //already exist, ignore
        fclose(fp);
        return;
    }
    
    p = strrchr(file, '\\');
    if(p != NULL)
    {
        p++;
    }
    else
    {
        p = (char *)file;
    }
    printf("\r                                                                      \rConverting %s...\n", p);        
    
    fioData = ReadFromFile(fio, file);
    if(fioData != NULL)
    {
        strupr(suffix);
        if(strcmp(suffix, "I420")==0)
        {
            format = YUV_I420;
        }
        else if(strcmp(suffix, "YV12")==0)
        {
            format = YUV_YV12;
        }
        else if(strcmp(suffix, "NV12")==0)
        {
            format = YUV_NV12;
        }
        else if(strcmp(suffix, "NV21")==0)
        {
            format = YUV_NV21;
        }

        yuv2bmpfile(format, fioData->buffer, width, height, bmpFile);
        
        FreeData(fio, fioData);
    }
}
Ejemplo n.º 22
0
int menu(int *f){
    int op,i,opcion,x,columna=43,fila=6;
    int pos;
    char nombre[20];
    char aapp[15];
    static  Alumno Alum[Max];
    static int contAlum=0;

    system("cls");
    switch(*f){
        case INICIO+3:
            system("cls");
            gotoxy(50,10);printf("AGREGAR ALUMNO");
            Captura(Alum,&contAlum);
            gotoxy(43,27);printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
            getch();
        break;
        case INICIO+6:
            system("cls");
            if(band == 1){
                gotoxy(columna,fila+3);printf("ELIMINAR ALUMNO");
                gotoxy(columna-25,fila+6);printf("APELLIDO PATERNO ");
                fflush(stdin);
                gotoxy(columna-23,fila+8);gets(aapp);
                strupr(aapp);
                gotoxy(columna+5,fila+6);printf("NOMBRE ");
                fflush(stdin);
                gotoxy(columna,fila+8);gets(nombre);
                strupr(nombre);
                for(i=0; i<contAlum; i++)
                    if(Alum[i].Edad != 0)
                        Eliminar(Alum,&contAlum,i,nombre,aapp);
                    else
                        gotoxy(columna,fila+24);printf("EL ALUMNO NO EXISTE");
                gotoxy(40,27);printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                getch();
            }
            else{
                gotoxy(40,7);printf("...NO HAY DATOS CAPTURADOS...");
                getch();
            }
        break;
        case INICIO+9:
            if(band == 1){
                do{
                    system("cls");
                    gotoxy(columna,fila+3);printf("MOSTRAR ALUMNO");
                    gotoxy(columna,fila+6);printf("1. NOMBRE");
                    gotoxy(columna,fila+9);printf("2. APELLIDO PATERNO");
                    gotoxy(columna,fila+12);printf("3. APELLIDO MATERNO");
                    gotoxy(columna,fila+15);printf("4. EDAD");
                    gotoxy(columna,fila+18);printf("5. SEMESTRE");
                    gotoxy(columna,fila+21);printf("6. SALIR");
                    gotoxy(columna,fila+24);printf("Elige una Opcion: ");
                    scanf("%d",&opcion);
                    switch(opcion){
                        case 1:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ALUMNOS");
                            insercionNom(Alum,contAlum);
                            i=0;
                            do{
                                mostrarAlum(Alum,i);
                                i++;
                            }while(i<contAlum);
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        case 2:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ALUMNOS");
                            quickSortAP(Alum,0,(contAlum-1));
                            for(i=0; i<contAlum; i++)
                                mostrarAlum(Alum,i);
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        case 3:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ALUMNOS");
                            burbujaMejoradoAM(Alum,contAlum);
                            for(i=0; i<contAlum; i++)
                                mostrarAlum(Alum,i);
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        case 4:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ALUMNOS");
                            seleccionEdad(Alum,contAlum);
                            for(i=0; i<contAlum; i++)
                                mostrarAlum(Alum,i);
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        case 5:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ALUMNOS");
                            shellSortSem(Alum,contAlum);
                            for(i=0; i<contAlum; i++)
                                mostrarAlum(Alum,i);
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        case 6:
                            system("cls");
                            gotoxy(columna+5,fila);printf("ABANDONAR MENU MOSTRAR...");
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                        break;
                        default:
                            system("cls");
                            gotoxy(columna+5,fila);printf("OPCION INCORRECTA");
                            gotoxy(columna,fila+(i+15));printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                            getch();
                    }
                }while(opcion != 6);
            }
            else{
                gotoxy(40,7);printf("...NO HAY DATOS CAPTURADOS...");
                getch();
            }
        break;
        case INICIO+12:
            if(band == 1){
                system("cls");
                gotoxy(columna,fila+3);printf("BUSQUEDA");
                gotoxy(columna-25,fila+6);printf("APELLIDO PATERNO");
                fflush(stdin);
                gotoxy(columna-23,fila+8);gets(aapp);
                strupr(aapp);
                gotoxy(columna-10,fila+6);printf("NOMBRE:");
                fflush(stdin);
                gotoxy(columna-10,fila+6);gets(nombre);
                strupr(nombre);
                pos=busquedaBinaria(Alum,contAlum,aapp,nombre);
                if(x != -1){
                    if(Alum[pos].Edad != 0){
                        system("cls");
                        printf("ALUMNOS ENCONTRADOS");
                        mostrarAlum(Alum,pos);
                        gotoxy(40,7);printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                        getch();
                    }
                    else
                        gotoxy(43,23);printf("ALUMNO NO ENCONTRADO");
                }
                else
                    gotoxy(43,23);printf("ALUMNO NO ENCONTRADO");
                gotoxy(40,7);printf("...PRESIONA UNA TECLA PARA CONTINUAR...");
                getch();
            }
            else{
                gotoxy(40,7);printf("...NO HAY DATOS CAPTURADOS...");
                getch();
            }
        break;
        case INICIO+15:
            system("cls");
            gotoxy(columna+15,fila);printf("...ABANDONAR PROGRAMA...");
            gotoxy(columna+5,fila+2);printf("...PRESIONA UNA TECLA PARA CONTINUAR...\n");
            getch();
            return 27;
        break;
    }
    return 0;
}
Ejemplo n.º 23
0
int sbbs_t::exec_misc(csi_t* csi, char *path)
{
	char	str[512],tmp[512],buf[1025],ch,op,*p,**pp,**pp1,**pp2;
	ushort	w;
	uint 	i=0,j;
	long	l,*lp=NULL,*lp1=NULL,*lp2=NULL;
	void	*vp;
	struct	dirent *de;
    struct  tm tm;

	switch(*(csi->ip++)) {
		case CS_VAR_INSTRUCTION:
			switch(*(csi->ip++)) {	/* sub-op-code stored as next byte */
				case PRINT_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					if(!pp || !*pp) {
						lp=getintvar(csi,*(long *)csi->ip);
						if(lp)
							bprintf("%ld",*lp); }
					else
						putmsg(cmdstr(*pp,path,csi->str,buf)
							,P_SAVEATR|P_NOABORT|P_NOATCODES);
					csi->ip+=4;
					return(0);
				case VAR_PRINTF:
				case VAR_PRINTF_LOCAL:
					op=*(csi->ip-1);
					p=format_string(this, csi);
					if(op==VAR_PRINTF)
						putmsg(cmdstr(p,path,csi->str,buf),P_SAVEATR|P_NOABORT|P_NOATCODES);
					else {
						if(online==ON_LOCAL)
							eprintf(LOG_INFO,"%s",cmdstr(p,path,csi->str,buf));
						else
							lputs(LOG_INFO,cmdstr(p,path,csi->str,buf));
					}
					free(p);
					return(0);
				case SHOW_VARS:
					bprintf("shell     str=(%08lX) %s\r\n"
						,csi->str,csi->str);
					for(i=0;i<csi->str_vars;i++)
						bprintf("local  str[%d]=(%08lX) (%08lX) %s\r\n"
							,i,csi->str_var_name[i]
							,csi->str_var[i]
							,csi->str_var[i]);
					for(i=0;i<csi->int_vars;i++)
						bprintf("local  int[%d]=(%08lX) (%08lX) %ld\r\n"
							,i,csi->int_var_name[i]
							,csi->int_var[i]
							,csi->int_var[i]);
					for(i=0;i<global_str_vars;i++)
						bprintf("global str[%d]=(%08lX) (%08lX) %s\r\n"
							,i,global_str_var_name[i]
							,global_str_var[i]
							,global_str_var[i]);
					for(i=0;i<global_int_vars;i++)
						bprintf("global int[%d]=(%08lX) (%08lX) %ld\r\n"
							,i,global_int_var_name[i]
							,global_int_var[i]
							,global_int_var[i]);
					return(0);
				case DEFINE_STR_VAR:
					if(getstrvar(csi,*(long *)csi->ip)) {
						csi->ip+=4;
						return(0); }
					csi->str_vars++;
					csi->str_var=(char **)realloc(csi->str_var
						,sizeof(char *)*csi->str_vars);
					csi->str_var_name=(long *)realloc(csi->str_var_name
						,sizeof(long)*csi->str_vars);
					if(csi->str_var==NULL
						|| csi->str_var_name==NULL) { /* REALLOC failed */
						errormsg(WHERE,ERR_ALLOC,"local str var"
							,sizeof(char *)*csi->str_vars);
						if(csi->str_var_name) {
							free(csi->str_var_name);
							csi->str_var_name=0; }
						if(csi->str_var) {
							free(csi->str_var);
							csi->str_var=0; }
						csi->str_vars=0; }
					else {
						csi->str_var_name[csi->str_vars-1]=*(long *)csi->ip;
						csi->str_var[csi->str_vars-1]=0; }
					csi->ip+=4; /* Skip variable name */
					return(0);
				case DEFINE_INT_VAR:
					if(getintvar(csi,*(long *)csi->ip)) {
						csi->ip+=4;
						return(0); }
					csi->int_vars++;
					csi->int_var=(long *)realloc(csi->int_var
						,sizeof(char *)*csi->int_vars);
					csi->int_var_name=(long *)realloc(csi->int_var_name
						,sizeof(long)*csi->int_vars);
					if(csi->int_var==NULL
						|| csi->int_var_name==NULL) { /* REALLOC failed */
						errormsg(WHERE,ERR_ALLOC,"local int var"
							,sizeof(char *)*csi->int_vars);
						if(csi->int_var_name) {
							free(csi->int_var_name);
							csi->int_var_name=0; }
						if(csi->int_var) {
							free(csi->int_var);
							csi->int_var=0; }
						csi->int_vars=0; }
					else {
						csi->int_var_name[csi->int_vars-1]=*(long *)csi->ip;
						csi->int_var[csi->int_vars-1]=0; }
					csi->ip+=4; /* Skip variable name */
					return(0);
				case DEFINE_GLOBAL_STR_VAR:
					if(getstrvar(csi,*(long *)csi->ip)) {
						csi->ip+=4;
						return(0); }
					global_str_vars++;
					global_str_var=(char **)realloc(global_str_var
						,sizeof(char *)*global_str_vars);
					global_str_var_name=(long *)realloc(global_str_var_name
						,sizeof(long)*global_str_vars);
					if(global_str_var==NULL
						|| global_str_var_name==NULL) { /* REALLOC failed */
						errormsg(WHERE,ERR_ALLOC,"global str var"
							,sizeof(char *)*global_str_vars);
						if(global_str_var_name) {
							free(global_str_var_name);
							global_str_var_name=0; }
						if(global_str_var) {
							free(global_str_var);
							global_str_var=0; }
						global_str_vars=0; }
					else {
						global_str_var_name[global_str_vars-1]=
							*(long *)csi->ip;
						global_str_var[global_str_vars-1]=0; }
					csi->ip+=4; /* Skip variable name */
					return(0);
				case DEFINE_GLOBAL_INT_VAR:
					if(getintvar(csi,*(long *)csi->ip)) {
						csi->ip+=4;
						return(0); }
					global_int_vars++;
					global_int_var=(long *)realloc(global_int_var
						,sizeof(char *)*global_int_vars);
					global_int_var_name=(long *)realloc(global_int_var_name
						,sizeof(long)*global_int_vars);
					if(global_int_var==NULL
						|| global_int_var_name==NULL) { /* REALLOC failed */
						errormsg(WHERE,ERR_ALLOC,"local int var"
							,sizeof(char *)*global_int_vars);
						if(global_int_var_name) {
							free(global_int_var_name);
							global_int_var_name=0; }
						if(global_int_var) {
							free(global_int_var);
							global_int_var=0; }
						global_int_vars=0; }
					else {
						global_int_var_name[global_int_vars-1]
							=*(long *)csi->ip;
						global_int_var[global_int_vars-1]=0; }
					csi->ip+=4; /* Skip variable name */
					return(0);

				case SET_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					if(pp)
						*pp=copystrvar(csi,*pp
							,cmdstr((char *)csi->ip,path,csi->str,buf));
					while(*(csi->ip++));	 /* Find NULL */
					return(0);
				case SET_INT_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					if(lp)
						*lp=*(long *)csi->ip;
					csi->ip+=4; /* Skip value */
					return(0);
				case COMPARE_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					if(pp && *pp)
						csi->logic=stricmp(*pp
							,cmdstr((char *)csi->ip,path,csi->str,buf));
					else {	/* Uninitialized str var */
						if(*(csi->ip)==0)	 /* Blank static str */
							csi->logic=LOGIC_TRUE;
						else
							csi->logic=LOGIC_FALSE; }
					while(*(csi->ip++));	 /* Find NULL */
					return(0);
				case STRSTR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					if(pp && *pp && strstr(*pp
						,cmdstr((char *)csi->ip,path,csi->str,buf)))
						csi->logic=LOGIC_TRUE;
					else
						csi->logic=LOGIC_FALSE;
					while(*(csi->ip++));	 /* Find NULL */
					return(0);
				case STRNCMP_VAR:
					i=*csi->ip++;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					if(pp && *pp)
						csi->logic=strnicmp(*pp
							,cmdstr((char *)csi->ip,path,csi->str,buf),i);
					else
						csi->logic=LOGIC_FALSE;
					while(*(csi->ip++));	 /* Find NULL */
					return(0);
				case STRNCMP_VARS:
					i=*csi->ip++;
					pp1=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp1 && *pp1 && pp2 && *pp2)
						csi->logic=strnicmp(*pp1,*pp2,i);
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case STRSTR_VARS:
					pp1=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp1 && *pp1 && pp2 && *pp2 && strstr(*pp1,*pp2))
						csi->logic=LOGIC_TRUE;
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case COMPARE_INT_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					l=*(long *)csi->ip;
					csi->ip+=4; /* Skip static value */
					if(!lp) {	/* Unknown variable */
						csi->logic=LOGIC_FALSE;
						return(0); }
					if(*lp>l)
						csi->logic=LOGIC_GREATER;
					else if(*lp<l)
						csi->logic=LOGIC_LESS;
					else
						csi->logic=LOGIC_EQUAL;
					return(0);
				case COMPARE_VARS:
					lp1=lp2=0;
					pp1=getstrvar(csi,*(long *)csi->ip);
					if(!pp1)
						lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					if(!pp2)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */

					if(((!pp1 || !*pp1) && !lp1)
						|| ((!pp2 || !*pp2) && !lp2)) {
						if(pp1 && pp2)		/* Both unitialized or blank */
							csi->logic=LOGIC_TRUE;
						else
							csi->logic=LOGIC_FALSE;
						return(0); }

					if(pp1) { /* ASCII */
						if(!pp2) {
							ultoa(*lp2,tmp,10);
							csi->logic=stricmp(*pp1,tmp); }
						else
							csi->logic=stricmp(*pp1,*pp2);
						return(0); }

					/* Binary */
					if(!lp2) {
						l=strtol(*pp2,0,0);
						if(*lp1>l)
							csi->logic=LOGIC_GREATER;
						else if(*lp1<l)
							csi->logic=LOGIC_LESS;
						else
							csi->logic=LOGIC_EQUAL;
						return(0); }
					if(*lp1>*lp2)
						csi->logic=LOGIC_GREATER;
					else if(*lp1<*lp2)
						csi->logic=LOGIC_LESS;
					else
						csi->logic=LOGIC_EQUAL;
					return(0);
				case COPY_VAR:
					lp1=lp2=0;
					pp1=getstrvar(csi,*(long *)csi->ip);
					if(!pp1)
						lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					if(!pp2)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */

					if((!pp1 && !lp1)
						|| ((!pp2 || !*pp2) && !lp2)) {
						csi->logic=LOGIC_FALSE;
						return(0); }
					csi->logic=LOGIC_TRUE;

					if(pp1) {	/* ASCII */
						if(!pp2)
							ultoa(*lp2,tmp,10);
						else
							strcpy(tmp,*pp2);
						*pp1=copystrvar(csi,*pp1,tmp);
						return(0); }
					if(!lp2)
						*lp1=strtol(*pp2,0,0);
					else
						*lp1=*lp2;
					return(0);
				case SWAP_VARS:
					lp1=lp2=0;
					pp1=getstrvar(csi,*(long *)csi->ip);
					if(!pp1)
						lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					if(!pp2)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */

					if(((!pp1 || !*pp1) && !lp1)
						|| ((!pp2 || !*pp2) && !lp2)) {
						csi->logic=LOGIC_FALSE;
						return(0); }

					csi->logic=LOGIC_TRUE;

					if(pp1) {	/* ASCII */
						if(!pp2) {
							if(!strnicmp(*pp2,"0x",2)) {
								l=strtol((*pp1)+2,0,16);
								ultoa(*lp2,tmp,16); }
							else {
								l=atol(*pp1);
								ultoa(*lp2,tmp,10); }
							*pp1=copystrvar(csi,*pp1,tmp);
							*lp2=l; }
						else {
							p=*pp1;
							*pp1=*pp2;
							*pp2=p; }
						return(0); }

					/* Binary */
					if(!lp2) {
						if(!strnicmp(*pp2,"0x",2)) {
							l=strtol((*pp2)+2,0,16);
							ultoa(*lp1,tmp,16); }
						else {
							l=atol(*pp2);
							ultoa(*lp1,tmp,10); }
						*pp2=copystrvar(csi,*pp2,tmp);
						*lp1=l; }
					else {
						l=*lp1;
						*lp1=*lp2;
						*lp2=l; }
					return(0);
				case CAT_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					strcpy(tmp,(char *)csi->ip);
					while(*(csi->ip++));
					if(pp && *pp)
						for(i=0;i<MAX_SYSVARS;i++)
							if(*pp==sysvar_p[i])
								break;
					if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
						if(*pp)
							*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
						else
							*pp=(char *)realloc(*pp,strlen(tmp)+1); }
					if(pp && *pp)
						strcat(*pp,tmp);
					return(0);
				case CAT_STR_VARS:
					pp1=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip dest variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip source variable name */

					/* Concatenate an int var to a str var (as char) */
					if(pp2==NULL) {
						lp=getintvar(csi,*(long *)(csi->ip-4));
						if(lp==NULL) {
							csi->logic=LOGIC_FALSE;
							return(0);
						}
						pp=pp1;
						tmp[0]=(uchar)*lp;
						tmp[1]=0;
						if(pp && *pp)
							for(i=0;i<MAX_SYSVARS;i++)
								if(*pp==sysvar_p[i])
									break;
						if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
							if(*pp)
								*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
							else
								*pp=(char *)realloc(*pp,strlen(tmp)+1); }
						if(pp && *pp)
							strcat(*pp,tmp);
						return(0);
					}

					if(!pp1 || !pp2 || !*pp2) {
						csi->logic=LOGIC_FALSE;
						return(0); }
					csi->logic=LOGIC_TRUE;
					if(*pp1)
						for(i=0;i<MAX_SYSVARS;i++)
							if(*pp1==sysvar_p[i])
								break;
					if(*pp1!=csi->str && (!*pp1 || i==MAX_SYSVARS)) {
						if(*pp1)
							*pp1=(char *)realloc(*pp1,strlen(*pp1)+strlen(*pp2)+1);
						else
							*pp1=(char *)realloc(*pp1,strlen(*pp2)+1); }
					strcat(*pp1,*pp2);
					return(0);
				case FORMAT_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					p=format_string(this, csi);
					cmdstr(p,path,csi->str,str);
					if(pp)
						*pp=copystrvar(csi,*pp,str);
					free(p);
					return(0);
				case FORMAT_TIME_STR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					strcpy(str,(char *)csi->ip);
					while(*(csi->ip++));	/* Find NULL */
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && lp) {
						if(localtime_r((time_t *)lp,&tm)!=NULL) {
							strftime(buf,128,str,&tm);
							*pp=copystrvar(csi,*pp,buf); 
						} 
					}
					return(0);
				case TIME_STR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip str variable name */
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip int variable name */
					if(pp && lp) {
						strcpy(str,timestr((time_t *)lp));
						*pp=copystrvar(csi,*pp,str); }
					return(0);
				case DATE_STR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip str variable name */
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip int variable name */
					if(pp && lp) {
						unixtodstr(&cfg,*lp,str);
						*pp=copystrvar(csi,*pp,str); }
					return(0);
				case SECOND_STR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip str variable name */
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip int variable name */
					if(pp && lp) {
						sectostr(*lp,str);
						*pp=copystrvar(csi,*pp,str); }
					return(0);
				case STRUPR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						strupr(*pp);
					return(0);
				case STRLWR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						strlwr(*pp);
					return(0);
				case TRUNCSP_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						truncsp(*pp);
					return(0);
				case STRIP_CTRL_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						strip_ctrl(*pp);
					return(0);

				case ADD_INT_VAR:
				case SUB_INT_VAR:
				case MUL_INT_VAR:
				case DIV_INT_VAR:
				case MOD_INT_VAR:
				case AND_INT_VAR:
				case OR_INT_VAR:
				case NOT_INT_VAR:
				case XOR_INT_VAR:
					i=*(csi->ip-1);
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					l=*(long *)csi->ip;
					csi->ip+=4;
					if(!lp)
						return(0);
					switch(i) {
						case ADD_INT_VAR:
							*lp+=l;
							break;
						case SUB_INT_VAR:
							*lp-=l;
							break;
						case MUL_INT_VAR:
							*lp*=l;
							break;
						case DIV_INT_VAR:
							*lp/=l;
							break;
						case MOD_INT_VAR:
							*lp%=l;
							break;
						case AND_INT_VAR:
							*lp&=l;
							break;
						case OR_INT_VAR:
							*lp|=l;
							break;
						case NOT_INT_VAR:
							*lp&=~l;
							break;
						case XOR_INT_VAR:
							*lp^=l;
							break; }
					return(0);
				case COMPARE_ANY_BITS: 
				case COMPARE_ALL_BITS:
					i=*(csi->ip-1);
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					l=*(long *)csi->ip;
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(!lp)
						return(0);

					if(i==COMPARE_ANY_BITS) {
						if(((*lp)&l)!=0)
							csi->logic=LOGIC_TRUE;
					} else {
						if(((*lp)&l)==l)
							csi->logic=LOGIC_TRUE;
					}
					return(0);
				case ADD_INT_VARS:
				case SUB_INT_VARS:
				case MUL_INT_VARS:
				case DIV_INT_VARS:
				case MOD_INT_VARS:
				case AND_INT_VARS:
				case OR_INT_VARS:
				case NOT_INT_VARS:
				case XOR_INT_VARS:
					i=*(csi->ip-1);
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					lp2=getintvar(csi,*(long *)csi->ip);
					if(!lp2) {
						pp=getstrvar(csi,*(long *)csi->ip);
						if(!pp || !*pp)
							return(0);
						l=strtol(*pp,0,0); }
					else
						l=*lp2;
					csi->ip+=4;
					if(!lp1)
						return(0);
					switch(i) {
						case ADD_INT_VARS:
							*lp1+=l;
							break;
						case SUB_INT_VARS:
							*lp1-=l;
							break;
						case MUL_INT_VARS:
							*lp1*=l;
							break;
						case DIV_INT_VARS:
							*lp1/=l;
							break;
						case MOD_INT_VARS:
							*lp1%=l;
							break;
						case AND_INT_VARS:
							*lp1&=l;
							break;
						case OR_INT_VARS:
							*lp1|=l;
							break;
						case NOT_INT_VARS:
							*lp1&=~l;
							break;
						case XOR_INT_VARS:
							*lp1^=l;
							break; }
					return(0);
				case RANDOM_INT_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					l=*(long *)csi->ip;
					csi->ip+=4;
					if(lp)
						*lp=sbbs_random(l);
					return(0);
				case TIME_INT_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp)
						*lp=time(NULL);
					return(0);
				case DATE_STR_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp && pp && *pp)
						*lp=dstrtounix(&cfg,*pp);
					return(0);
				case STRLEN_INT_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=strlen(*pp);
						else
							*lp=0; }
					return(0);
				case CRC16_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=crc16(*pp,0);
						else
							*lp=0; }
					return(0);
				case CRC32_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=crc32(*pp,0);
						else
							*lp=0; }
					return(0);
				case CHKSUM_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						*lp=0;
						if(pp && *pp) {
							i=0;
							while(*((*pp)+i))
								*lp+=(uchar)*((*pp)+(i++)); } }
					return(0);
				case FLENGTH_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=flength(*pp);
						else
							*lp=0; }
					return(0);
				case FTIME_TO_INT:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=fdate(*pp);
						else
							*lp=0; }
					return(0);
				case CHARVAL_TO_INT:
				case COPY_FIRST_CHAR:	// duplicate functionality - doh!
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=**pp;
						else
							*lp=0; }
					return(0);
				case GETSTR_VAR:
				case GETLINE_VAR:
				case GETNAME_VAR:
				case GETSTRUPR_VAR:
				case GETSTR_MODE:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					i=*(csi->ip++);
					csi->logic=LOGIC_FALSE;
					switch(*(csi->ip-6)) {
						case GETNAME_VAR:
							getstr(buf,i,K_UPRLWR);
							break;
						case GETSTRUPR_VAR:
							getstr(buf,i,K_UPPER);
							break;
						case GETLINE_VAR:
							getstr(buf,i,K_LINE);
							break;
						case GETSTR_MODE:
							l=*(long *)csi->ip;
							csi->ip+=4;
							if(l&K_EDIT) {
								if(pp && *pp)
									strcpy(buf,*pp);
								else
									buf[0]=0; }
							getstr(buf,i,l);
							break;
						default:
							getstr(buf,i,0); }
					if(sys_status&SS_ABORT)
						return(0);
					if(pp) {
						*pp=copystrvar(csi,*pp,buf);
						csi->logic=LOGIC_TRUE; }
					return(0);
				case GETNUM_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					if(!pp)
						lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					i=*(short *)csi->ip;
					csi->ip+=2;
					csi->logic=LOGIC_FALSE;
					l=getnum(i);
					if(!pp && !lp)
						return(0);
					if(pp) {
						if(l<=0)
							str[0]=0;
						else
							ultoa(l,str,10);
						*pp=copystrvar(csi,*pp,str);
						csi->logic=LOGIC_TRUE;
						return(0); }
					if(lp) {
						*lp=l;
						csi->logic=LOGIC_TRUE; }
					return(0);

				case SHIFT_STR_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					i=*(csi->ip++);
					if(!pp || !*pp)
						return(0);
					if(strlen(*pp)>=i)
						memmove(*pp,*pp+i,strlen(*pp)+1);
					return(0);

				case SHIFT_TO_FIRST_CHAR:
				case SHIFT_TO_LAST_CHAR:
					i=*(csi->ip-1);
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					ch=*(csi->ip++);
					csi->logic=LOGIC_FALSE;
					if(!pp || !*pp)
						return(0);
					if(i==SHIFT_TO_FIRST_CHAR)
						p=strchr(*pp,ch);
					else	/* _TO_LAST_CHAR */
						p=strrchr(*pp,ch);
					if(p==NULL)
						return(0);
					csi->logic=LOGIC_TRUE;
					i=p-*pp;
					if(i>0)
						memmove(*pp,*pp+i,strlen(p)+1);
					return(0);

				case CHKFILE_VAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp && fexistcase(cmdstr(*pp,path,csi->str,buf)))
						csi->logic=LOGIC_TRUE;
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case PRINTFILE_VAR_MODE:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					i=*(short *)(csi->ip);
					csi->ip+=2;
					if(pp && *pp)
						printfile(*pp,i);
					return(0);
				case PRINTTAIL_VAR_MODE:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					i=*(short *)(csi->ip);
					csi->ip+=2;
					j=*csi->ip;
					csi->ip++;
					if(pp && *pp)
						printtail(*pp,j,i);
					return(0);
				case TELNET_GATE_VAR:
					l=*(ulong *)(csi->ip);	// Mode
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						telnet_gate(*pp,l);
					return(0);
				case TELNET_GATE_STR:
					l=*(ulong *)(csi->ip);	// Mode
					csi->ip+=4;
					strcpy(str,(char *)csi->ip);
					while(*(csi->ip++));	/* Find NULL */
					telnet_gate(str,l);
					return(0);
				case COPY_CHAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					if(pp==NULL)
						lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;

					if(pp==NULL && lp!=NULL)
						*lp=csi->cmd;
					else if(pp!=NULL) {
						sprintf(tmp,"%c",csi->cmd);
						*pp=copystrvar(csi,*pp,tmp);
					}
					return(0);
				case COMPARE_FIRST_CHAR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					ch=*(csi->ip++);	/* char const */
					if(pp==NULL || *pp==NULL)
						csi->logic=LOGIC_FALSE;
					else {
						if(**pp==ch)
							csi->logic=LOGIC_EQUAL;
						else if(**pp>ch)
							csi->logic=LOGIC_GREATER;
						else 
							csi->logic=LOGIC_LESS;
					}
					return(0);

				case SEND_FILE_VIA:
				case RECEIVE_FILE_VIA:
					j=*(csi->ip-1);
					ch=*(csi->ip++);	/* Protocol */
					cmdstr((char *)csi->ip,csi->str,csi->str,str);
					while(*(csi->ip++));	/* Find NULL */
					for(i=0;i<cfg.total_prots;i++)
						if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
							break;
					csi->logic=LOGIC_FALSE;
					if(i<cfg.total_prots)
						if(protocol(cfg.prot[i],j==SEND_FILE_VIA ? XFER_DOWNLOAD : XFER_UPLOAD
							,str,str,true)==0)
							csi->logic=LOGIC_TRUE;
					return(0);
				case SEND_FILE_VIA_VAR:
				case RECEIVE_FILE_VIA_VAR:
					j=*(csi->ip-1);
					ch=*(csi->ip++);	/* Protocol */
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					for(i=0;i<cfg.total_prots;i++)
						if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
							break;
					csi->logic=LOGIC_FALSE;
					if(!pp || !(*pp))
						return(0);
					if(i<cfg.total_prots)
						if(protocol(cfg.prot[i]
							,j==SEND_FILE_VIA_VAR ? XFER_DOWNLOAD : XFER_UPLOAD
							,*pp,*pp,true)==0)
							csi->logic=LOGIC_TRUE;
					return(0);

				case MATCHUSER:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						if(pp && *pp)
							*lp=matchuser(&cfg, *pp, TRUE /*sysop_alias*/);
						else
							*lp=0; 
					}
					return(0);

				default:
					errormsg(WHERE,ERR_CHK,"var sub-instruction",*(csi->ip-1));
					return(0); }

		case CS_FIO_FUNCTION:
			switch(*(csi->ip++)) {	/* sub-op-code stored as next byte */
				case FIO_OPEN:
				case FIO_OPEN_VAR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					w=*(ushort *)csi->ip;
					csi->ip+=2;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-7)==FIO_OPEN) {
						cmdstr((char *)csi->ip,path,csi->str,str);
						while(*(csi->ip++)); }	 /* skip filename */
					else {
						pp=getstrvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!pp || !*pp)
							return(0);
						strcpy(str,*pp); }
					if(csi->files>=MAX_FOPENS)
						return(0);
					if(lp) {
						/* Access flags are not cross-platform, so convert */
						i=0;
						if(w&0x001) i|=O_RDONLY;
						if(w&0x002) i|=O_WRONLY;
						if(w&0x004) i|=O_RDWR;
						if(w&0x040) i|=O_DENYNONE;
						if(w&0x100) i|=O_CREAT;
						if(w&0x200) i|=O_TRUNC;
						if(w&0x400) i|=O_EXCL;
						if(w&0x800) i|=O_APPEND;
						*lp=(long)fnopen((int *)&j,str,i);
						if(*lp) {
							for(i=0;i<csi->files;i++)
								if(!csi->file[i])
									break;
							csi->file[i]=(FILE *)*lp;
							if(i==csi->files)
								csi->files++;
							csi->logic=LOGIC_TRUE; } }
					return(0);
				case FIO_CLOSE:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp && *lp) {
						csi->logic=fclose((FILE *)*lp);
						for(i=0;i<csi->files;i++)
							if(csi->file[i]==(FILE *)*lp)
								csi->file[i]=0; 
						*lp=0;
					}
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case FIO_FLUSH:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp && *lp)
						csi->logic=fflush((FILE *)*lp);
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case FIO_READ:
				case FIO_READ_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);		/* Handle */
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					if(!pp)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-9)==FIO_READ) {
						i=*(short *)csi->ip;
						csi->ip+=2; /* Length */ }
					else {			/* FIO_READ_VAR */
						vp=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!vp)
							return(0);
						i=*(short *)vp; }
					if(i>sizeof(buf)-1)
						i=sizeof(buf)-1;
					if(!lp1 || !(*lp1) || (!pp && !lp2))
						return(0);
					if(pp) {
						if(i<1) {
							if(*pp && **pp)
								i=strlen(*pp);
							else
								i=128; }
						if((j=fread(buf,1,i,(FILE *)*lp1))==i)
							csi->logic=LOGIC_TRUE;
						buf[j]=0;
						if(csi->etx) {
							p=strchr(buf,csi->etx);
							if(p) *p=0; }
						*pp=copystrvar(csi,*pp,buf); }
					else {
						*lp2=0;
						if(i>4 || i<1) i=4;
						if(fread(lp2,1,i,(FILE *)*lp1)==i)
							csi->logic=LOGIC_TRUE; }
					return(0);
				case FIO_READ_LINE:
					lp1=getintvar(csi,*(long *)csi->ip);		/* Handle */
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					if(!pp)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(!lp1 || !(*lp1) || feof((FILE *)*lp1) || (!pp && !lp2))
						return(0);
					csi->logic=LOGIC_TRUE;
					for(i=0;i<sizeof(buf)-1;i++) {
						if(!fread(buf+i,1,1,(FILE *)*lp1))
							break;
						if(*(buf+i)==LF) {
							i++;
							break; } }
					buf[i]=0;
					if(csi->etx) {
						p=strchr(buf,csi->etx);
						if(p) *p=0; }
					if(pp)
						*pp=copystrvar(csi,*pp,buf);
					else
						*lp2=strtol(buf,0,0);
					return(0);
				case FIO_WRITE:
				case FIO_WRITE_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					if(!pp)
						lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-9)==FIO_WRITE) {
						i=*(short *)csi->ip;
						csi->ip+=2; /* Length */ }
					else {			/* FIO_WRITE_VAR */
						vp=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!vp)
							return(0);
						i=*(short *)vp; }
					if(i>sizeof(buf)-1)
						i=sizeof(buf)-1;
					if(!lp1 || !(*lp1) || (!pp && !lp2) || (pp && !*pp))
						return(0);
					if(pp) {
						j=strlen(*pp);
						if(i<1) i=j;
						if(j>i) j=i;
						if(fwrite(*pp,1,j,(FILE *)*lp1)!=j)
							csi->logic=LOGIC_FALSE;
						else {
							if(j<i) {
								memset(buf,csi->etx,i-j);
								fwrite(buf,1,i-j,(FILE *)*lp1); 
							}
							csi->logic=LOGIC_TRUE; 
						}
					} else {
						if(i<1 || i>4) i=4;
						if(fwrite(lp2,1,i,(FILE *)*lp1)==i)
							csi->logic=LOGIC_TRUE; }
					return(0);
				case FIO_GET_LENGTH:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp1 && *lp1 && lp2)
						*lp2=filelength(fileno((FILE *)*lp1));
					return(0);
				case FIO_GET_TIME:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp1 && *lp1 && lp2) 
						*lp2=filetime(fileno((FILE *)*lp1));
					return(0);
				case FIO_SET_TIME:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
	#if 0 /* ftime */
					if(lp1 && *lp1 && lp2) {
						ft=unixtoftime(*lp2);
						setftime(fileno((FILE *)*lp1),&ft); }
	#endif
					return(0);
				case FIO_EOF:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(lp && *lp)
						if(ftell((FILE *)*lp)>=filelength(fileno((FILE *)*lp)))
							csi->logic=LOGIC_TRUE;
					return(0);
				case FIO_GET_POS:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					lp2=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp1 && *lp1 && lp2)
						*lp2=ftell((FILE *)*lp1);
					return(0);
				case FIO_SEEK:
				case FIO_SEEK_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-5)==FIO_SEEK) {
						l=*(long *)csi->ip;
						csi->ip+=4; }
					else {
						lp2=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!lp2) {
							csi->ip+=2;
							return(0); }
						l=*lp2; }
					i=*(short *)csi->ip;
					csi->ip+=2;
					if(lp1 && *lp1)
						if(fseek((FILE *)*lp1,l,i)!=-1)
							csi->logic=LOGIC_TRUE;
					return(0);
				case FIO_LOCK:
				case FIO_LOCK_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-5)==FIO_LOCK) {
						l=*(long *)csi->ip;
						csi->ip+=4; 
					} else {
						lp2=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!lp2)
							return(0);
						l=*lp2; 
					}
					if(lp1 && *lp1) {
						fflush((FILE *)*lp1);
						csi->logic=!lock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l); 
					}
					return(0);
				case FIO_UNLOCK:
				case FIO_UNLOCK_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-5)==FIO_UNLOCK) {
						l=*(long *)csi->ip;
						csi->ip+=4; 
					} else {
						lp2=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!lp2)
							return(0);
						l=*lp2; 
					}
					if(lp1 && *lp1) {
						fflush((FILE *)*lp1);
						csi->logic=!unlock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l); 
					}
					return(0);
				case FIO_SET_LENGTH:
				case FIO_SET_LENGTH_VAR:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(*(csi->ip-5)==FIO_SET_LENGTH) {
						l=*(long *)csi->ip;
						csi->ip+=4; 
					} else {
						lp2=getintvar(csi,*(long *)csi->ip);
						csi->ip+=4;
						if(!lp2)
							return(0);
						l=*lp2; }
					if(lp1 && *lp1)
						csi->logic=chsize(fileno((FILE *)*lp1),l);
					return(0);
				case FIO_PRINTF:
					lp1=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					p=format_string(this, csi);
					if(lp1 && *lp1) {
						cmdstr(p,path,csi->str,str);
						fwrite(str,1,strlen(str),(FILE *)*lp1); 
					}
					free(p);
					return(0);
				case FIO_SET_ETX:
					csi->etx=*(csi->ip++);
					return(0);
				case REMOVE_FILE:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp && remove(*pp)==0)
						csi->logic=LOGIC_TRUE;
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case RENAME_FILE:
				case COPY_FILE:
				case MOVE_FILE:
					pp1=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4; /* Skip variable name */
					pp2=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp1 && *pp1 && pp2 && *pp2)
						switch(*(csi->ip-9)) {
							case RENAME_FILE:
								csi->logic=rename(*pp1,*pp2);
								break;
							case COPY_FILE:
								csi->logic=mv(*pp1,*pp2,1);
								break;
							case MOVE_FILE:
								csi->logic=mv(*pp1,*pp2,0);
								break; }
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case GET_FILE_ATTRIB:
				case SET_FILE_ATTRIB:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp && lp) {
						if(*(csi->ip-9)==GET_FILE_ATTRIB)
							*lp=getfattr(*pp);
						else 
							*lp=CHMOD(*pp,(int)*lp); 
					}
					return(0);
				case MAKE_DIR:
				case REMOVE_DIR:
				case CHANGE_DIR:
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(pp && *pp)
						switch(*(csi->ip-5)) {
							case MAKE_DIR:
								csi->logic=MKDIR(*pp);
								break;
							case REMOVE_DIR:
								csi->logic=rmdir(*pp);
								break;
							case CHANGE_DIR:
								csi->logic=chdir(*pp);
								break; }
					else
						csi->logic=LOGIC_FALSE;
					return(0);

				case OPEN_DIR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(pp && *pp && lp) {
						*lp=(long)opendir((char *)*pp);
						if(*lp)
							csi->logic=LOGIC_TRUE; }
					return(0);
				case READ_DIR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					pp=getstrvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					csi->logic=LOGIC_FALSE;
					if(pp && lp) {
						de=readdir((DIR *)(*lp));
						if(de!=NULL) {
							csi->logic=LOGIC_TRUE;
							*pp=copystrvar(csi,*pp,de->d_name); } }
					return(0);
				case REWIND_DIR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp) {
						rewinddir((DIR *)(*lp));
						csi->logic=LOGIC_TRUE; }
					else
						csi->logic=LOGIC_FALSE;
					return(0);
				case CLOSE_DIR:
					lp=getintvar(csi,*(long *)csi->ip);
					csi->ip+=4;
					if(lp && closedir((DIR *)(*lp))==0)
						csi->logic=LOGIC_TRUE;
					else
						csi->logic=LOGIC_FALSE;
					return(0);

				default:
					errormsg(WHERE,ERR_CHK,"fio sub-instruction",*(csi->ip-1));
					return(0); }

		case CS_NET_FUNCTION:
			return(exec_net(csi));

		case CS_SWITCH:
			lp=getintvar(csi,*(long *)csi->ip);
			csi->ip+=4;
			if(!lp) {
				skipto(csi,CS_END_SWITCH);
				csi->ip++; }
			else {
				csi->misc|=CS_IN_SWITCH;
				csi->switch_val=*lp; }
			return(0);
		case CS_CASE:
			l=*(long *)csi->ip;
			csi->ip+=4;
			if(csi->misc&CS_IN_SWITCH && csi->switch_val!=l)
				skipto(csi,CS_NEXTCASE);
			else
				csi->misc&=~CS_IN_SWITCH;
			return(0);
		case CS_COMPARE_ARS:
			i=*(csi->ip++);  /* Length of ARS stored as byte before ARS */
			csi->logic=!chk_ar(csi->ip,&useron);
			csi->ip+=i;
			return(0);
		case CS_TOGGLE_USER_MISC:
			useron.misc^=*(ulong *)csi->ip;
			putuserrec(&cfg,useron.number,U_MISC,8,ultoa(useron.misc,tmp,16));
			csi->ip+=4;
			return(0);
		case CS_COMPARE_USER_MISC:
			if((useron.misc&*(ulong *)csi->ip)==*(ulong *)csi->ip)
				csi->logic=LOGIC_TRUE;
			else
				csi->logic=LOGIC_FALSE;
			csi->ip+=4;
			return(0);
		case CS_TOGGLE_USER_CHAT:
			useron.chat^=*(ulong *)csi->ip;
			putuserrec(&cfg,useron.number,U_CHAT,8,ultoa(useron.chat,tmp,16));
			csi->ip+=4;
			return(0);
		case CS_COMPARE_USER_CHAT:
			if((useron.chat&*(ulong *)csi->ip)==*(ulong *)csi->ip)
				csi->logic=LOGIC_TRUE;
			else
				csi->logic=LOGIC_FALSE;
			csi->ip+=4;
			return(0);
		case CS_TOGGLE_USER_QWK:
			useron.qwk^=*(ulong *)csi->ip;
			putuserrec(&cfg,useron.number,U_QWK,8,ultoa(useron.qwk,tmp,16));
			csi->ip+=4;
			return(0);
		case CS_COMPARE_USER_QWK:
			if((useron.qwk&*(ulong *)csi->ip)==*(ulong *)csi->ip)
				csi->logic=LOGIC_TRUE;
			else
				csi->logic=LOGIC_FALSE;
			csi->ip+=4;
			return(0);
		case CS_REPLACE_TEXT:
			i=*(ushort *)csi->ip;
			csi->ip+=2;
			i--;
			if(i>=TOTAL_TEXT) {
				errormsg(WHERE,ERR_CHK,"replace text #",i);
				while(*(csi->ip++));	 /* Find NULL */
				return(0); }
			if(text[i]!=text_sav[i] && text[i]!=nulstr)
				free(text[i]);
			j=strlen(cmdstr((char *)csi->ip,path,csi->str,buf));
			if(!j)
				text[i]=nulstr;
			else
				text[i]=(char *)malloc(j+1);
			if(!text[i]) {
				errormsg(WHERE,ERR_ALLOC,"replacement text",j);
				while(*(csi->ip++));	 /* Find NULL */
				text[i]=text_sav[i];
				return(0); }
			if(j)
				strcpy(text[i],buf);
			while(*(csi->ip++));	 /* Find NULL */
			return(0);
		case CS_USE_INT_VAR:	// Self-modifying code!
			pp=getstrvar(csi,*(long *)csi->ip);
			if(pp && *pp)
				l=strtol(*pp,0,0);
			else {
				lp=getintvar(csi,*(long *)csi->ip);
				if(lp)
					l=*lp;
				else
					l=0; }
			csi->ip+=4; 			// Variable
			i=*(csi->ip++); 		// Offset
			if(i<1 || csi->ip+1+i>=csi->cs+csi->length) {
				errormsg(WHERE,ERR_CHK,"offset",i);
				csi->ip++;
				return(0); }
			switch(*(csi->ip++)) {	// Length
				case sizeof(char):
					*(csi->ip+i)=(char)l;
					break;
				case sizeof(short):
					*((short *)(csi->ip+i))=(short)l;
					break;
				case sizeof(long):
					*((long *)(csi->ip+i))=l;
					break;
				default:
					errormsg(WHERE,ERR_CHK,"length",*(csi->ip-1));
					break; }
			return(0);
		default:
			errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
			return(0); }
}
Ejemplo n.º 24
0
int main(int argc, char **argv)
{
	char*	p;
	char	error[512];
	char	revision[16];
	int		i;
	int		first_arg=1;
	time_t	now;
	user_t	user;

	sscanf("$Revision$", "%*s %s", revision);

	fprintf(stderr,"\nMAKEUSER v%s-%s - Adds User to Synchronet User Database\n"
		,revision
		,PLATFORM_DESC
		);

	if(argc<2) {
		printf("%s",usage);
		return(1); 
	}

	if(strcspn(argv[first_arg],"/\\")!=strlen(argv[first_arg]))
		p=argv[first_arg++];
	else
		p=getenv("SBBSCTRL");
	if(p==NULL) {
		printf("\nSBBSCTRL environment variable not set.\n");
		printf("\nExample: SET SBBSCTRL=/sbbs/ctrl\n");
		exit(1); 
	}

	memset(&scfg,0,sizeof(scfg));
	scfg.size=sizeof(scfg);
	SAFECOPY(scfg.ctrl_dir,p);

	if(chdir(scfg.ctrl_dir)!=0)
		fprintf(stderr,"!ERROR changing directory to: %s", scfg.ctrl_dir);

	printf("\nLoading configuration files from %s\n",scfg.ctrl_dir);
	if(!load_cfg(&scfg,NULL,TRUE,error)) {
		fprintf(stderr,"!ERROR loading configuration files: %s\n",error);
		exit(1);
	}

	now=time(NULL);

	memset(&user,0,sizeof(user));

	/****************/
	/* Set Defaults */
	/****************/

	/* security */
	user.level=scfg.new_level;
	user.flags1=scfg.new_flags1;
	user.flags2=scfg.new_flags2;
	user.flags3=scfg.new_flags3;
	user.flags4=scfg.new_flags4;
	user.rest=scfg.new_rest;
	user.exempt=scfg.new_exempt; 

	user.cdt=scfg.new_cdt;
	user.min=scfg.new_min;
	user.freecdt=scfg.level_freecdtperday[user.level];

	if(scfg.total_fcomps)
		strcpy(user.tmpext,scfg.fcomp[0]->ext);
	else
		strcpy(user.tmpext,"ZIP");
	for(i=0;i<scfg.total_xedits;i++)
		if(!stricmp(scfg.xedit[i]->code,scfg.new_xedit))
			break;
	if(i<scfg.total_xedits)
		user.xedit=i+1;

	user.shell=scfg.new_shell;
	user.misc=(scfg.new_misc&~(DELETED|INACTIVE|QUIET|NETMAIL));
	user.misc|=AUTOTERM;	/* No way to frob the default value... */
	user.qwk=QWK_DEFAULT;
	user.firston=(time32_t)now;
	user.laston=(time32_t)now;	/* must set this or user may be purged prematurely */
	user.pwmod=(time32_t)now;
	user.sex=' ';
	user.prot=scfg.new_prot;

	if(scfg.new_expire)
		user.expire=(time32_t)(now+((long)scfg.new_expire*24L*60L*60L)); 

	for(i=first_arg;i<argc;i++) {
		if(argv[i][0]=='-') {
			if(argv[i+1]==NULL) {
				printf("%s",usage);
				return(1);
			}
			switch(toupper(argv[i++][1])) {
			case 'A':
				SAFECOPY(user.address,argv[i]);
				break;
			case 'B':
				SAFECOPY(user.birth,argv[i]);
				break;
			case 'L':
				SAFECOPY(user.location,argv[i]);
				break;
			case 'C':
				SAFECOPY(user.comment,argv[i]);
				break;
			case 'E':
				user.expire=(time32_t)(now+((long)atoi(argv[i])*24L*60L*60L)); 
				break;
			case 'F':
				switch(toupper(argv[i-1][2])) {
					case '1':
						user.flags1=aftol(argv[i]);
						break;
					case '2':
						user.flags2=aftol(argv[i]);
						break;
					case '3':
						user.flags3=aftol(argv[i]);
						break;
					case '4':
						user.flags4=aftol(argv[i]);
						break;
					case 'E':
						user.exempt=aftol(argv[i]);
						break;
					case 'R':
						user.rest=aftol(argv[i]);
						break;
					default:
						printf("%s",usage);
						return(1);
				}
				break;
			case 'G':
				user.sex=toupper(argv[i][0]);
				break;
			case 'H':
				SAFECOPY(user.handle,argv[i]);
				break;
			case 'N':
				SAFECOPY(user.netmail,argv[i]);
				break;
			case 'P':
				SAFECOPY(user.pass,argv[i]);
				strupr(user.pass);
				break;
			case 'R':
				SAFECOPY(user.name,argv[i]);
				break;
			case 'S':
				user.level=atoi(argv[i]);
				break;
			case 'T':
				SAFECOPY(user.phone,argv[i]);
				break;
			case 'Z':
				SAFECOPY(user.zipcode,argv[i]);
				break;
			default:
				printf("%s",usage);
				return(1); 
			}
		}
		else
			SAFECOPY(user.alias,argv[i]);
	}

	if(user.alias[0]==0) {
		printf("%s",usage);
		return(1);
	}

	if((i=matchuser(&scfg,user.alias,FALSE))!=0) {
		printf("!User (%s #%d) already exists\n",user.alias,i);
		return(2);
	}

	if(user.handle[0]==0)
		SAFECOPY(user.handle,user.alias);
	if(user.name[0]==0)
		SAFECOPY(user.name,user.alias);

	if((i=newuserdat(&scfg, &user))!=0) {
		fprintf(stderr,"!ERROR %d adding new user record\n",i);
		return(i);
	}

	printf("User record #%d (%s) created successfully.\n",user.number,user.alias);

	return(0);
}
Ejemplo n.º 25
0
bool sbbs_t::qwk_import_msg(FILE *qwk_fp, char *hdrblk, ulong blocks
							,char fromhub, uint subnum
							,uint touser, smbmsg_t* msg)
{
	char*		body;
	char*		tail;
	char*		qwkbuf;
	char		str[256],col=0,lastch=0,*p;
	char		from[128];
	uint 		i,k;
	long		bodylen,taillen;
	bool		success=false;
	uint16_t	net_type;
	ushort		xlat=XLAT_NONE;
	int			storage=SMB_SELFPACK;
	long		dupechk_hashes=SMB_HASH_SOURCE_DUPE;
	str_list_t	kludges;

	if(subnum!=INVALID_SUB
		&& (hdrblk[0]=='*' || hdrblk[0]=='+' || cfg.sub[subnum]->misc&SUB_PONLY))
		msg->hdr.attr|=MSG_PRIVATE;
	if(subnum!=INVALID_SUB && cfg.sub[subnum]->misc&SUB_AONLY)
		msg->hdr.attr|=MSG_ANONYMOUS;
	if(subnum==INVALID_SUB && cfg.sys_misc&SM_DELREADM)
		msg->hdr.attr|=MSG_KILLREAD;
	if((fromhub || useron.rest&FLAG('Q')) &&
		(hdrblk[0]=='*' || hdrblk[0]=='-' || hdrblk[0]=='`'))
		msg->hdr.attr|=MSG_READ;

	if(subnum!=INVALID_SUB && !fromhub && cfg.sub[subnum]->mod_ar[0]
		&& chk_ar(cfg.sub[subnum]->mod_ar,&useron,&client))
		msg->hdr.attr|=MSG_MODERATED;
	if(subnum!=INVALID_SUB && !fromhub && cfg.sub[subnum]->misc&SUB_SYSPERM
		&& sub_op(subnum))
		msg->hdr.attr|=MSG_PERMANENT;

	if(!(useron.rest&FLAG('Q')) && !fromhub && msg->hdr.when_written.zone==0)
		msg->hdr.when_written.zone=sys_timezone(&cfg);

	msg->hdr.when_imported.time=time32(NULL);
	msg->hdr.when_imported.zone=sys_timezone(&cfg);

	hdrblk[116]=0;	// don't include number of blocks in "re: msg number"
	if(!(useron.rest&FLAG('Q')) && !fromhub)
		msg->hdr.thread_back=atol((char *)hdrblk+108);

	if(subnum==INVALID_SUB) { 		/* E-mail */
		if(cfg.sys_misc&SM_FASTMAIL)
			storage=SMB_FASTALLOC;

		/* duplicate message-IDs must be allowed in mail database */
		dupechk_hashes&=~(1<<SMB_HASH_SOURCE_MSG_ID);

		sprintf(str,"%u",touser);
		smb_hfield_str(msg,RECIPIENTEXT,str); 
	} else {
		if(cfg.sub[subnum]->misc&SUB_HYPER)
			storage = SMB_HYPERALLOC;
		else if(cfg.sub[subnum]->misc&SUB_FAST)
			storage = SMB_FASTALLOC;

		if(cfg.sub[subnum]->misc&SUB_LZH)
			xlat=XLAT_LZH;
	}

	/********************************/
	/* Convert the QWK message text */
	/********************************/

	if((qwkbuf=(char *)malloc((blocks-1)*QWK_BLOCK_LEN))==NULL) {
		errormsg(WHERE,ERR_ALLOC,"QWK msg buf",(blocks-1)*QWK_BLOCK_LEN);
		return(false); 
	}

	if(fread(qwkbuf,QWK_BLOCK_LEN,blocks-1,qwk_fp) != blocks-1) {
		free(qwkbuf);
		errormsg(WHERE,ERR_READ,"QWK msg blocks",(blocks-1)*QWK_BLOCK_LEN);
	}

	bodylen=0;
	if((body=(char *)malloc((blocks-1L)*QWK_BLOCK_LEN*2L))==NULL) {
		free(qwkbuf);
		errormsg(WHERE,ERR_ALLOC,"QWK msg body",(blocks-1L)*QWK_BLOCK_LEN*2L);
		return(false); 
	}

	taillen=0;
	if((tail=(char *)malloc((blocks-1L)*QWK_BLOCK_LEN*2L))==NULL) {
		free(qwkbuf);
		free(body);
		errormsg(WHERE,ERR_ALLOC,"QWK msg tail",(blocks-1L)*QWK_BLOCK_LEN*2L);
		return(false); 
	}

	kludges=strListInit();

	for(k=0;k<(blocks-1)*QWK_BLOCK_LEN;k++) {
		if(qwkbuf[k]==0)
			continue;
		if(bodylen==0 
			&& (qwkbuf[k]=='@' 
				|| (((useron.qwk&QWK_EXT) || subnum==INVALID_SUB)
					&& (strnicmp(qwkbuf+k,"To:",3)==0 
					||  strnicmp(qwkbuf+k,"From:",5)==0 
					||  strnicmp(qwkbuf+k,"Subject:",8)==0)))) {
			if((p=strchr(qwkbuf+k, QWK_NEWLINE))==NULL) {
				body[bodylen++]=qwkbuf[k];
				continue;
			}
			*p=0;	/* Converts QWK_NEWLINE to NUL */
			strListPush(&kludges, qwkbuf+k);
			k+=strlen(qwkbuf+k);
			continue;
		}
		if(!taillen && qwkbuf[k]==' ' && col==3 && bodylen>=3
			&& body[bodylen-3]=='-' && body[bodylen-2]=='-'
			&& body[bodylen-1]=='-') {
			bodylen-=3;
			strcpy(tail,"--- ");	/* DO NOT USE SAFECOPY */
			taillen=4;
			col++;
			continue; 
		}
		if(qwkbuf[k]==QWK_NEWLINE) {		/* expand QWK_NEWLINE to crlf */
			if(!bodylen && !taillen)		/* Ignore blank lines at top of message */
				continue;
			if(!taillen && col==3 && bodylen>=3 && body[bodylen-3]=='-'
				&& body[bodylen-2]=='-' && body[bodylen-1]=='-') {
				bodylen-=3;
				strcpy(tail,"---");	/* DO NOT USE SAFECOPY */
				taillen=3; 
			}
			col=0;
			if(taillen) {
				tail[taillen++]=CR;
				tail[taillen++]=LF; 
			}
			else {
				body[bodylen++]=CR;
				body[bodylen++]=LF; 
			}
			continue; 
		}
		/* beep restrict */
		if(!fromhub && qwkbuf[k]==BEL && useron.rest&FLAG('B'))   
			continue;
		/* ANSI restriction */
		if(!fromhub && (qwkbuf[k]==CTRL_A || qwkbuf[k]==ESC)
			&& useron.rest&FLAG('A'))
			continue;
		if(qwkbuf[k]!=CTRL_A && lastch!=CTRL_A)
			col++;
		if(lastch==CTRL_A && !valid_ctrl_a_code(qwkbuf[k])) {
			if(taillen) taillen--;
			else		bodylen--;
			lastch=0;
			continue; 
		}
		lastch=qwkbuf[k];
		if(taillen)
			tail[taillen++]=qwkbuf[k];
		else
			body[bodylen++]=qwkbuf[k]; 
	} 
	free(qwkbuf);

	while(bodylen && body[bodylen-1]==' ') bodylen--; /* remove trailing spaces */
	if(bodylen>=2 && body[bodylen-2]==CR && body[bodylen-1]==LF)
		bodylen-=2;

	while(taillen && tail[taillen-1]<=' ') taillen--; /* remove trailing garbage */

	/* Parse QWK Kludges (QWKE standard and SyncQNET legacy) here: */
	if(useron.rest&FLAG('Q') || fromhub) {      /* QWK Net */
		if((p=iniGetString(kludges,ROOT_SECTION,"@VIA",NULL,NULL)) != NULL) {
			if(!fromhub)
				set_qwk_flag(QWK_VIA);
			if(route_circ(p,cfg.sys_id)) {
				bprintf("\r\nCircular message path: %s\r\n",p);
				lprintf(LOG_ERR,"Circular message path: %s from %s"
					,p,fromhub ? cfg.qhub[fromhub-1]->id:useron.alias);
				strListFree(&kludges);
				free(body);
				free(tail);
				return(false); 
			}
			SAFEPRINTF2(str,"%s/%s"
				,fromhub ? cfg.qhub[fromhub-1]->id : useron.alias,p);
			strupr(str);
			update_qwkroute(str); 
		}
		else {
			if(fromhub)
				SAFECOPY(str,cfg.qhub[fromhub-1]->id);
			else
				SAFECOPY(str,useron.alias); 
		}
		/* From network type & address: */
		strupr(str);
		net_type=NET_QWK;
		smb_hfield_netaddr(msg, SENDERNETADDR, str, &net_type);
		smb_hfield_bin(msg,SENDERNETTYPE,net_type);

	} else {
		sprintf(str,"%u",useron.number);
		smb_hfield_str(msg,SENDEREXT,str);
		if((uint)subnum!=INVALID_SUB && cfg.sub[subnum]->misc&SUB_NAME)
			SAFECOPY(from,useron.name);
		else
			SAFECOPY(from,useron.alias);
		smb_hfield_str(msg,SENDER,from);
	}
	if((p=iniGetString(kludges,ROOT_SECTION,"@MSGID",NULL,NULL)) != NULL) {
		if(!fromhub)
			set_qwk_flag(QWK_MSGID);
		truncstr(p," ");				/* Truncate at first space char */
		if(msg->id==NULL)
			smb_hfield_str(msg,RFC822MSGID,p);
	}
	if((p=iniGetString(kludges,ROOT_SECTION,"@REPLY",NULL,NULL)) != NULL) {
		if(!fromhub)
			set_qwk_flag(QWK_MSGID);
		truncstr(p," ");				/* Truncate at first space char */
		if(msg->reply_id==NULL)
			smb_hfield_str(msg,RFC822REPLYID,p);
	}
	if((p=iniGetString(kludges,ROOT_SECTION,"@TZ",NULL,NULL)) != NULL) {
		if(!fromhub)
			set_qwk_flag(QWK_TZ);
		msg->hdr.when_written.zone=(short)ahtoul(p); 
	}
	if((p=iniGetString(kludges,ROOT_SECTION,"@REPLYTO",NULL,NULL)) != NULL) {
		if(msg->replyto==NULL)
			smb_hfield_str(msg,REPLYTO,p);
	}
	/* QWKE standard: */
	if((p=iniGetString(kludges,ROOT_SECTION,"Subject",NULL,NULL)) != NULL)
		smb_hfield_replace_str(msg,SUBJECT,p);
	if((p=iniGetString(kludges,ROOT_SECTION,"To",NULL,NULL)) != NULL)
		smb_hfield_replace_str(msg,RECIPIENT,p);
	if((useron.rest&FLAG('Q'))
		&& (p=iniGetString(kludges,ROOT_SECTION,"From",NULL,NULL)) != NULL)
		smb_hfield_replace_str(msg,SENDER,p);

	strListFree(&kludges);

	/* smb_addmsg requires ASCIIZ strings */
	body[bodylen]=0;
	tail[taillen]=0;

	if(online==ON_REMOTE)
		bputs(text[WritingIndx]);

	if(smb.status.max_crcs==0)	/* no CRC checking means no body text dupe checking */
		dupechk_hashes&=~(1<<SMB_HASH_SOURCE_BODY);

	if((i=smb_addmsg(&smb,msg,storage,dupechk_hashes,xlat,(uchar*)body,(uchar*)tail))==SMB_SUCCESS)
		success=true;
	else if(i==SMB_DUPE_MSG) {
		bprintf("\r\n!%s\r\n",smb.last_error);
		if(!fromhub) {
			if(subnum==INVALID_SUB) {
				SAFEPRINTF2(str,"%s duplicate e-mail attempt (%s)",useron.alias,smb.last_error);
				logline(LOG_NOTICE,"E!",str); 
			} else {
				SAFEPRINTF4(str,"%s duplicate message attempt in %s %s (%s)"
					,useron.alias
					,cfg.grp[cfg.sub[subnum]->grp]->sname
					,cfg.sub[subnum]->lname
					,smb.last_error);
				logline(LOG_NOTICE,"P!",str); 
			}
		}
	}
	else 
		errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);

	free(body);
	free(tail);

	return(success);
}
Ejemplo n.º 26
0
// low-level keyboard hook function
static LRESULT CALLBACK 
	LLKeyboardProc(
		int nCode, 
		WPARAM wParam, 
		LPARAM lParam
		) 
{
	PKBDLLHOOKSTRUCT HookStruct = (PKBDLLHOOKSTRUCT)lParam;

	DWORD CurrentThread;
	HWND  hForeground,hFocus = NULL;

	DWORD ProcessID = 0;
	DWORD ThreadID  = 0;
	DWORD HostProcess = 0;
	HANDLE hProcess;
	BOOL bAttached = FALSE;
	CHAR  ProcessName[MAX_PATH];
	
#ifdef _DEBUG
	lstrcpy(ProcessName, szUnknown);
#endif

	do {
		if ( !g_bLoggerEnabled || ( nCode != HC_ACTION ) || !HookStruct ){
			break;
		}

		if ( (UINT)wParam != WM_KEYDOWN ){ //message 
			break;
		}

		CurrentThread = GetCurrentThreadId();
		hForeground = GetForegroundWindow();

#ifndef _DEBUG
		ProcessName[0] = 0;
#endif
		if ( hForeground == NULL ){
			DbgPrint("GetForegroundWindow is NULL\n");
			break;
		}

		// get thread and process for foreground window
		if ( ThreadID = GetWindowThreadProcessId(hForeground,&ProcessID) )
		{
			if ( CurrentThread != ThreadID ){
				bAttached =
					AttachThreadInput(
						CurrentThread,
						ThreadID,
						TRUE
						);
			}
		}else{
			DbgPrint("GetWindowThreadProcessId failed, err=%lu\n",GetLastError());
		}

		// wnd that owns focus can be handled by different thread
		hFocus = GetFocus();
		if ( hFocus != hForeground )
		{
			// detach input
			if ( bAttached ){
				AttachThreadInput(
					CurrentThread,
					ThreadID,
					FALSE
					);
				bAttached = FALSE;
			}
			if ( ThreadID = GetWindowThreadProcessId(hFocus,&ProcessID) )
			{
				if ( CurrentThread != ThreadID ){
					bAttached =
						AttachThreadInput(
							CurrentThread,
							ThreadID,
							TRUE
							);
				}
			}else{
				DbgPrint("GetWindowThreadProcessId failed, err=%lu\n",GetLastError());
			}
		}

		if ( ProcessID ){
			hProcess = 
				OpenProcess(
					PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
					FALSE,
					ProcessID
					);
			if ( hProcess )
			{
				if ( GetModuleBaseNameA(hProcess,NULL,ProcessName,MAX_PATH) ){
					strupr(ProcessName);
					HostProcess = Crc32(ProcessName, lstrlenA(ProcessName));
				}else{
					DbgPrint("GetModuleBaseName failed, err=%lu\n",GetLastError());
				}
				CloseHandle(hProcess);
			}else{
				DbgPrint("OpenProcess failed, err=%lu\n",GetLastError());
			}
		}

		// log kbd event
		KeyProcessMessage( 
			hFocus, 
			(UINT)wParam, //message 
			(UINT)HookStruct->vkCode, 
			(UINT)HookStruct->scanCode, 
			ProcessID,
			ThreadID,
			HostProcess
#ifdef _DEBUG
			,ProcessName
#endif
			);

		if ( bAttached ){
			AttachThreadInput(
				CurrentThread,
				ThreadID,
				FALSE
				);
		}
	} while ( FALSE );

	return CallNextHookEx(0, nCode, wParam, lParam);
}
Ejemplo n.º 27
0
static int
match_ms_upn_san(krb5_context context,
		 krb5_kdc_configuration *config,
		 hx509_context hx509ctx,
		 hx509_cert client_cert,
		 krb5_const_principal match)
{
    hx509_octet_string_list list;
    krb5_principal principal = NULL;
    int ret, found = 0;
    MS_UPN_SAN upn;
    size_t size;

    memset(&list, 0 , sizeof(list));

    ret = hx509_cert_find_subjectAltName_otherName(hx509ctx,
						   client_cert,
						   oid_id_pkinit_ms_san(),
						   &list);
    if (ret)
	goto out;

    if (list.len != 1) {
	kdc_log(context, config, 0,
		"More then one PK-INIT MS UPN SAN");
	goto out;
    }

    ret = decode_MS_UPN_SAN(list.val[0].data, list.val[0].length, &upn, &size);
    if (ret) {
	kdc_log(context, config, 0, "Decode of MS-UPN-SAN failed");
	goto out;
    }

    kdc_log(context, config, 0, "found MS UPN SAN: %s", upn);

    ret = krb5_parse_name(context, upn, &principal);
    free_MS_UPN_SAN(&upn);
    if (ret) {
	kdc_log(context, config, 0, "Failed to parse principal in MS UPN SAN");
	goto out;
    }

    /*
     * This is very wrong, but will do for now, should really and a
     * plugin to the windc layer to very this ACL.
    */
    strupr(principal->realm);

    if (krb5_principal_compare(context, principal, match) == TRUE)
	found = 1;

out:
    if (principal)
	krb5_free_principal(context, principal);
    hx509_free_octet_string_list(&list);
    if (ret)
	return ret;

    if (!found)
	return KRB5_KDC_ERR_CLIENT_NAME_MISMATCH;

    return 0;
}
Ejemplo n.º 28
0
PFN wrapper_get_addr( const tsd_t *TSD, const struct library *lptr, const streng *name )
{
   PFN addr;
   handle_type handle=(handle_type)lptr->handle;
   char *funcname ;
#if defined(DYNAMIC_WIN32)
   char LoadError[256];
   char *entryname;
   unsigned u;
   char c;
#endif
#if defined(DYNAMIC_OS2)
   char *entryname;
   unsigned u;
   char c;
   ULONG ordinal;
   APIRET rc=0L;
#endif
#if defined(DYNAMIC_BEOS)
   status_t rc=0;
#endif
#if defined(DYNAMIC_STATIC)
   int rc=0;
#endif
#if defined(MODULES_NEED_USCORE)
   streng *us_func;
#endif

   funcname = str_of( TSD, name ) ;

#if defined(DYNAMIC_STATIC)
   rc = static_dlsym( handle, funcname,(void **)&addr );
   if ( rc != 0 )
   {
      char buf[150];
      sprintf(buf,"static_dlsym() failed with %d looking for %s", rc, funcname );
      set_err_message(TSD,  buf, "" ) ;
      addr = NULL;
   }
#elif defined(DYNAMIC_DLOPEN)
# if defined(MODULES_NEED_USCORE)
   /*
    * Some platforms need to have an underscore prepended to the function
    * name to be found in a loadable module.
    */
   FreeTSD( funcname );
   us_func = Str_makeTSD( Str_len( name ) + 1 );
   memcpy( us_func->value, "_", 1 );
   us_func->len = 1;
   Str_catTSD( us_func, name );
   funcname = str_of( TSD, us_func );
   Free_stringTSD( us_func );
# endif
   /*
    * Note, the following assignment is not allowed by ANSI, but SVR4.2
    * includes it as an example, so it is probably safe in this context
    */
   addr = (PFN)(dlsym( handle, funcname )) ;

   /* deal with, eg 'SysLoadFuncs' when the function is 'sysloadfuncs' or 'SYSLOADFUNCS' */
   if (addr == NULL)
   {
      mem_upper( funcname, strlen( funcname ) );
      addr = (PFN)(dlsym( handle, funcname )) ;

      if (addr == NULL)
      {
         mem_lower( funcname, strlen( funcname ) );
         addr = (PFN)(dlsym( handle, funcname )) ;

         if (addr==NULL)
            set_err_message( TSD,  "dlsym() failed: ", dlerror() );
      }
   }

#elif defined(DYNAMIC_HPSHLOAD)
   {
      long eaddr ;
      int rc;

      if (rc = shl_findsym( &handle, funcname, TYPE_PROCEDURE, &eaddr ))
      {
         mem_upper( funcname, strlen( funcname ) );
         if (rc = shl_findsym( &handle, funcname, TYPE_PROCEDURE, &eaddr ))
         {
            mem_lower( funcname, strlen( funcname ) );
            if (rc = shl_findsym( &handle, funcname, TYPE_PROCEDURE, &eaddr ))
            {
               addr = NULL ;
               set_err_message( TSD,  "shl_findsym() failed: ", strerror(errno) );
            }
         }
      }

      if (!rc)
         addr = (PFN)eaddr ;
   }

#elif defined(DYNAMIC_AIXLOAD)
   addr = (PFN)handle ;

#elif defined(DYNAMIC_OS2)
   if ( ( sscanf( funcname, "#%u%c", &u, &c ) == 1 ) && ( u != 0 ) )
   {
      ordinal = (ULONG) u;
      entryname = NULL;
   }
   else
   {
      ordinal = 0L;
      entryname = funcname;
   }
   rc = DosQueryProcAddr(handle,ordinal,entryname,&addr);
   if (rc)
   {
      char buf[150];
      sprintf(buf,"DosQueryProcAddr() failed with %lu looking for %.90s", (long) rc, funcname );
      set_err_message(TSD, buf, "" ) ;
   }

#elif defined(DYNAMIC_WIN32)
   /*  13/12/1999 JH moved cast, (HMODULE), from second parm to first.  Removed
    * a compiler warning,
    */
   if ( ( sscanf( funcname, "#%u%c", &u, &c ) == 1 ) && ( u != 0 ) &&
                                                             ( u <= 0xFFFF ) )
      entryname = (char *) u;
   else
      entryname = funcname;

   addr = (PFN) GetProcAddress( (HMODULE) handle, entryname );

   if ( ( addr == NULL ) && ( funcname == entryname ) )
   {
      strlwr(funcname);
      addr = (PFN)GetProcAddress((HMODULE)handle,funcname);

      if (addr == NULL)
      {
         strupr(funcname);
         addr = (PFN)GetProcAddress((HMODULE)handle, funcname);
      }
   }
   if (addr == NULL)
   {
      char buf[150];
      FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT), LoadError, 256, NULL );
      sprintf( buf, "Failed to find \"%s\" in external library: GetProcAddress() failed: ", funcname );
      set_err_message( TSD, buf, LoadError );
   }

#elif defined(DYNAMIC_BEOS)
   rc = get_image_symbol(handle,funcname,B_SYMBOL_TYPE_TEXT,(void **)&addr);
   if (rc == B_BAD_IMAGE_ID)
   {
      char buf[150];
      sprintf(buf,"get_image_symbol() failed with %d looking for %s", rc, funcname );
      set_err_message( TSD,  buf, "" );
      addr = NULL;
   }

#elif defined(DYNAMIC_SKYOS)
fprintf(stderr,"%s %d:\n",__FILE__,__LINE__);
   addr = (PFN)GetDllFunction( handle, funcname );
   if ( addr == NULL )
   {
      char buf[150];
      sprintf(buf,"GetDllFunction() failed looking for %s", funcname );
      set_err_message( TSD,  buf, "" );
      addr = NULL;
   }
fprintf(stderr,"%s %d:\n",__FILE__,__LINE__);
#endif

   FreeTSD( funcname );

   if (addr)
      return (PFN)addr ;
   else
      return NULL ;
}
Ejemplo n.º 29
0
msgmenu()
{
char prompt[80],s[80],k[80];
int i;

cur=i=0;
initmsg();
if(user.sl < bidx[0].level)
	{
	nl();
	nl();
	put("4You can't access the first section");
	return;
	}
if(bidx[0].pass[0]!=0)
	{
	put("1Enter file base password:2 ");
	input(s,50);
	nl();
	if(stricmp(bidx[0].pass,s)!=0)
		{
		pl("4Sorry, wrong password");
		return;
		}
	}


if(dispnoerr("MWELC.ANS")==-1)
	{
	put_char(12);
	put("4");
	print("���������������������������������������ķ"); nl();
	print("� Conference:                           �"); nl();
	print("� Current Base:                         �"); nl();
	print("���������������������������������������Ķ"); nl();
	print("� Total Msgs:                           �"); nl();
	print("� Last Read :                           �"); nl();
	print("���������������������������������������Ľ"); nl();
	ccursor(2,15);
	print("2%d - %s",cidx[curconf].num,cidx[curconf].name);
	ccursor(3,17);
	print("2%d - %s",bidx[cur].num,bidx[cur].name);
	gettotalmsgs();
	ccursor(5,15);
	print("3%d",totalmsgs);
	ccursor(6,15);
	print("30");
	nl();
	nl();
	nl();
	}

gettotalmsgs();

while(1)
	{
	nl();
	setmci(1);
	print("4[1%d left4 * [3Area %d4] 1Message Menu4]:2 ",chktime()/60,bidx[cur].num);
	setmci(0);
	input(s,50);
	strupr(s);
	switch(s[0])
		{
		case 'R':
			readpost();
			break;
		case 'P':
			post();
			break;
		case 'A':
			printboard();
			break;
		case 'G':
			logoff();
			break;
		case '?':
			do_help("MSG");
			break;
		case 'J':
			confmenu();
			msgmenu();
			break;
		case '!':
			if(user.sl > 200)
				msgsysop();
			break;
		case 'Q':
			return;
		default:
			if(isdigit(s[0]))
				{
				i=atoi(s);
				if(i <= numread && i > 0 && user.sl >= bidx[i-1].level)
					{
					if(fileidx[i-1].pass[0]!=0)
						{
						nl();
						put("1Enter file base password:2 ");
						input(k,50);
						if(stricmp(bidx[i-1].pass,k)!=0)
							{
							nl();
							pl("4Sorry, wrong password");
							}
						else
							{
							cur=i-1;
							gettotalmsgs();
							}
						}
					else
						{
						cur=i-1;
						gettotalmsgs();
						}
					}
				}
			break;
		}
	}
}
Ejemplo n.º 30
0
uint sbbs_t::finduser(char *instr)
{
	int file,i;
	char str[128],str2[256],str3[256],ynq[25],c,pass=1;
	long l,length;
	FILE *stream;

	i=atoi(instr);
	if(i>0) {
		username(&cfg, i,str2);
		if(str2[0] && strcmp(str2,"DELETED USER"))
			return(i); 
	}
	strcpy(str,instr);
	strupr(str);
	SAFEPRINTF(str3,"%suser/name.dat",cfg.data_dir);
	if(flength(str3)<1L)
		return(0);
	if((stream=fnopen(&file,str3,O_RDONLY))==NULL) {
		errormsg(WHERE,ERR_OPEN,str3,O_RDONLY);
		return(0); 
	}
	SAFEPRINTF(ynq,"%.2s",text[YN]);
	ynq[2]='Q';
	ynq[3]=0;
	length=(long)filelength(file);
	while(pass<3) {
		fseek(stream,0L,SEEK_SET);	/* seek to beginning for each pass */
		for(l=0;l<length;l+=LEN_ALIAS+2) {
			if(!online) break;
			fread(str2,LEN_ALIAS+2,1,stream);
			for(c=0;c<LEN_ALIAS;c++)
				if(str2[c]==ETX) break;
			str2[c]=0;
			if(!c)		/* deleted user */
				continue;
			strcpy(str3,str2);
			strupr(str2);
			if(pass==1 && !strcmp(str,str2)) {
				fclose(stream);
				return((l/(LEN_ALIAS+2))+1); 
			}
			if(pass==2 && strstr(str2,str)) {
				bprintf(text[DoYouMeanThisUserQ],str3
					,(uint)(l/(LEN_ALIAS+2))+1);
				c=(char)getkeys(ynq,0);
				if(sys_status&SS_ABORT) {
					fclose(stream);
					return(0); 
				}
				if(c==text[YN][0]) {
					fclose(stream);
					return((l/(LEN_ALIAS+2))+1); 
				}
				if(c=='Q') {
					fclose(stream);
					return(0); 
				} 
			} 
		}
		pass++; 
	}
	bputs(text[UnknownUser]);
	fclose(stream);
	return(0);
}