// // Purpose: // Entry point function. Executes specified command from user. // // Parameters: // Command-line syntax is: svcconfig [command] [service_path] // // Return value: // None // void __cdecl _tmain(int argc, TCHAR *argv[]) { printf("\n"); if( argc != 3 ) { printf("ERROR:\tIncorrect number of arguments\n\n"); DisplayUsage(); return; } StringCchCopy(szCommand, 10, argv[1]); StringCchCopy(szSvcName, 80, argv[2]); if (lstrcmpi( szCommand, TEXT("query")) == 0 ) DoQuerySvc(); else if (lstrcmpi( szCommand, TEXT("describe")) == 0 ) DoUpdateSvcDesc(); else if (lstrcmpi( szCommand, TEXT("disable")) == 0 ) DoDisableSvc(); else if (lstrcmpi( szCommand, TEXT("enable")) == 0 ) DoEnableSvc(); else if (lstrcmpi( szCommand, TEXT("delete")) == 0 ) DoDeleteSvc(); else { _tprintf(TEXT("Unknown command (%s)\n\n"), szCommand); DisplayUsage(); } }
int main( int argc, char **argv ) { //Initialize easylogging InitializeLogger(); //TODO - Use boost cmdline args if( argc < 3 ) { DisplayUsage(); return EXIT_FAILURE; } else { std::unique_ptr<CMultiTrackerApp> trackerApp( new CMultiTrackerApp( argv ) ); if( !trackerApp->Initialize() ) { LOG( INFO ) << ">>>> Application Failed To Initialize <<<<"; return false; } trackerApp->Run(); LOG( INFO ) << ">>>> Application Closing <<<<"; return EXIT_SUCCESS; } }
int main( int argc, char *argv[] ) { HANDLE handle; int i; printf("\nStart %s...\n", argv[0]); for (i = 1; i < argc; i++) { switch ( *argv[i] ) { case 'h': case '?': DisplayUsage( argv[0] ); break; case 'o': if ( !OpenMailslot( argv[i] + 1, &handle ) ) { return 3; } break; case 'n': if ( !NotifyChangeDirectoryTest() ) { return 3; } break; case 'c': printf( "Closing file\n" ); NtClose( handle ); break; case 'w': if (!WriteTest(handle)) { return 3; } break; case 'v': if (!QueryVolumeTest()) { return 3; } break; default: printf( "Unknown test ""%s"" skipped.\n", argv[i] ); } } printf( "%s exiting\n", argv[0]); return 0; }
int main(int argc, char **argv) { int c; int index; // Presence of option character will set correspond flag char aflag = 0; char tflag = 0; char *tvalue = NULL; opterr = 0; // prevents the default error messages of getopt() while ((c = getopt (argc, argv, "abt:")) != -1) { // Set option flags switch (c) { case 'a': aflag = 1; break; case 't': tflag = 1; tvalue = optarg; break; case '?': // getopt detected invalid option character or missing target if (optopt == 't') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (isprint (optopt)) fprintf (stderr, "Unknown option `-%c'.\n", optopt); else fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); return 1; // Error! default: abort (); // Critical Error! } } if (argc == 1) DisplayUsage(argv[0]); /********Shift Execution based on option flags********/ else { printf ("aflag = %d, tflag = %d, tvalue = %s\n", aflag, tflag, tvalue); } /********* Process non-option argv arguments *********/ for (index = optind; index < argc; index++) { // Process non-option arguments printf ("Non-option argument \"%s\" @ argv[%d]\n", argv[index], index); } return 0; }
/** Display all help. */ void DisplayHelp() { DisplayUsage(); printf(" -display X Set the X display to use\n"); printf(" -exit Exit JWM (send _JWM_EXIT to the root)\n"); printf(" -h Display this help message\n"); printf(" -p Parse the configuration file and exit\n"); printf(" -restart Restart JWM (send _JWM_RESTART to the root)\n"); printf(" -v Display version information\n"); }
int main(int argc, char* argv[]) { int speed; if (argc == 3) { if (sscanf(argv[1],"-s%d",&speed) != 1) { DisplayUsage(); return 0; } NextImage(argv[2], speed); } else if(argc == 2) { speed = 1000; NextImage(argv[1], speed); } else DisplayUsage(); return 0; }
int main(int argc, char * argv[]) { int result = 0; SLPToolCommandLine cmdline; /* zero out the cmdline */ memset(&cmdline, 0, sizeof(cmdline)); /* Parse the command line */ if (ParseCommandLine(argc, argv, &cmdline) == 0) switch (cmdline.cmd) { case FINDSRVS: FindSrvs(&cmdline); break; case FINDATTRS: FindAttrs(&cmdline); break; case FINDSRVTYPES: FindSrvTypes(&cmdline); break; case FINDSCOPES: FindScopes(&cmdline); break; case GETPROPERTY: GetProperty(&cmdline); break; case REGISTER: Register(&cmdline); break; case DEREGISTER: Deregister(&cmdline); break; case PRINT_VERSION: PrintVersion(&cmdline); break; case DUMMY: break; } else { DisplayUsage(); result = 1; } return result; }
void Options::DisplayError (const Exceptions& aErr) { const char* msg; switch (aErr) { case EUnknownOption: msg = "Unknown option specified"; DisplayUsage (); break; case EMissingRegistryEntry: msg = "One of the registry entry (PkgUID ,PkgName and VendorName ) not specified"; DisplayUsage (); break; case EMissingPkgUID: msg = "Package UID not specified "; DisplayUsage (); break; case EInvalidOption: msg = "Invalid option specified "; DisplayUsage (); break; case EInvalidPackageUID: msg = "Invalid Package UID"; break; case ESetEnvironmentVariable: msg = "Set the environment variable or \nspecify registry file path"; break; case EInvalidFile: msg = "Registry format not supported ."; break; default: msg = "Unknown error"; break; } cerr << CommandName () << ": Error : " << msg << endl; }
void CCommandParser::DisplayError( int aError ) { const wchar_t* msg; // switch( aError ) { case ECmdLineUnknownOption: msg = L"Unknown option specified"; break; case ECmdLineMissingParamFile: msg = L"Can't open the parameter file specified"; break; case ECmdLineNoDirArgument: msg = L"No directory(s) specified"; break; case ECmdLineNoSisArgument: msg = L"No SIS file(s) specified"; break; case ECmdLineNoRomRofsLogsArgument: msg = L"No ROM/ROFS[BUILD] log file(s) specified"; break; case ECmdLineNoConfigFileArgument: msg = L"No configuration file specified"; break; case ECmdLineNoSisStubPathArgument: msg = L"No SIS stub directory specified"; break; case ECmdLineMissingParams: msg = L"Missing parameters"; break; case ECmdLineInvalidLanguage: msg = L"Invalid language code"; break; case ECmdLineMissingPackageUID: msg = L"Package UID not found"; break; default: msg = L"Unknown error"; break; } // LERROR(msg << std::endl); DisplayUsage(); }
void Options::DisplayError (CmdLineException err) { const char* msg; switch (err) { case ECmdLineUnknownOption: msg = "unknown option specified"; break; case ECmdLineMissingSIS: msg = "no SIS file specified"; break; case ECmdLineMultipleSIS: msg = "too many SIS files specified"; break; case ECmdLineNoDirArgument: msg = "No argument supplied with the -d flag"; break; case ECmdLineDirIsFile: msg = "Directory specified with the -d flag is a file"; break; case ECmdLineNoPermission: msg = "Permission was denied when using directory specified with -d"; break; case ECmdLineOtherDirFailure: msg = "Operation failed when accessing directory specified with -d"; break; case ECmdLineInvalidDir: msg = "Directory name specified with -d could not be created, invalid name"; break; default: msg = "unknown error"; break; } std::cerr << CommandName () << ": Error in command: " << msg << std::endl; DisplayUsage (); }
int parseCommandLine() { int iRet = 0; int iNumArgs, iNumToBeProcessed; LPTSTR lpstrCommandArgs=GetCommandLine(); LPTSTR *rgCmdArgs=CommandLineToArgvW(lpstrCommandArgs,&iNumArgs); // To take care of no command line arguments if (iNumArgs <= 1 ) { iRet = -1; goto Cleanup; } // Check if one argument only and that is the /? argument if (0==_tcsncicmp(rgCmdArgs[1],CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) { DisplayUsage(); iRet = 1; goto Cleanup; } // if more than one argument but not the required 2 arguments if (iNumArgs < 3 ) { iRet = -1; goto Cleanup; } CAzGlobalOptions::m_bstrDestStoreName.Attach(CComBSTR(rgCmdArgs[1]).Copy()); CAzGlobalOptions::m_bstrSourceStoreName.Attach(CComBSTR(rgCmdArgs[2]).Copy()); CAzGlobalOptions::setDefaults(); iNumToBeProcessed = iNumArgs-3; for (int i = 3 ; i < iNumArgs ; i++) { // Checking for /logfile if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::LOGFILETAG,CAzGlobalOptions::LOGFILETAG_LEN)) { _TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('=')); if (NULL==strRightPart) { iRet = -1; goto Cleanup; } CAzLogging::Initialize(CAzLogging::LOG_LOGFILE,&strRightPart[1]); iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::APPNAMETAG,CAzGlobalOptions::APPNAMETAG_LEN)) { //Checking for /application flag LPTSTR strTmp; _TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('=')); if (NULL==strRightPart) { iRet = -1; goto Cleanup; } CAzGlobalOptions::m_bSpecificApp=true; _TCHAR *strAppNames =_tcstok_s(&strRightPart[1],_TEXT(","),&strTmp); while (strAppNames!=NULL) { CAzGlobalOptions::m_bstrAppNames.push_back(CComBSTR(strAppNames).Copy()); /* While there are tokens in "string" */ /* Get next token: */ strAppNames =_tcstok_s(NULL,_TEXT(","),&strTmp); } iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::OVERWRITETAG , CAzGlobalOptions::OVERWRITETAG_LEN)) { //Checking for /overwrite flag CAzGlobalOptions::m_bOverWrite=true; iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREMEMBERSTAG,CAzGlobalOptions::IGNOREMEMBERSTAG_LEN)) { //Checking for /IGNOREMEMBERS flag CAzGlobalOptions::m_bIgnoreMembers=true; iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREPOLICYADMINSTAG , CAzGlobalOptions::IGNOREPOLICYADMINSTAG_LEN)) { //Checking for /IGNOREPOLICYADMIN flag CAzGlobalOptions::m_bIgnorePolicyAdmins=true; iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::VERBOSETAG , CAzGlobalOptions::VERBOSETAG_LEN)) { CAzGlobalOptions::m_bVerbose=true; CAzLogging::Initialize(CAzLogging::LOG_TRACE); iNumToBeProcessed--; } else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) { DisplayUsage(); iNumToBeProcessed--; iRet = 1; goto Cleanup; } } // Some additional parameters exist which donot match // hence these are invalid flags. if (0 != iNumToBeProcessed) { iRet = -1; goto Cleanup; } iRet = 0; Cleanup: if (rgCmdArgs) { LocalFree(rgCmdArgs); } return iRet; }
main (int argc, char *argv[]) { char *mppfile; char *option; bool verbose; char readln[FILENAME_MAX]; double x; double y; double lat; double lon; int status; mapx_class *the_map; /* * set defaults */ verbose = FALSE; /* * get command line options */ while (--argc > 0 && (*++argv)[0] == '-') { for (option = argv[0]+1; *option != '\0'; option++) { switch (*option) { case 'v': verbose = TRUE; break; default: fprintf(stderr,"invalid option %c\n", *option); DisplayUsage(); } } } /* * get command line arguments */ if (argc != 1) DisplayUsage(); mppfile = *argv++; if (verbose) { fprintf(stderr, " mppfile = %s\n", mppfile); fprintf(stderr, " ll2xy_c_rcsid = %s\n", ll2xy_c_rcsid); } /* * initialize the map */ the_map = init_mapx(mppfile); if (NULL == the_map) exit(ABORT); /* * keep reading lines until eof */ for (;;) { gets(readln); if (!feof(stdin)) { /* * get x-y pair */ sscanf(readln, "%lf %lf", &lat, &lon); /* * convert x-y pair to latitude-longitude pair */ status = forward_xy_mapx(the_map, lat, lon, &x, &y); /* * print lat, lon, x, y, and status */ printf("%11.7lf %12.7lf %17.7lf %17.7lf %2d\n", lat, lon, x, y, status); } else { /* * close the map */ close_mapx(the_map); break; } } exit(EXIT_SUCCESS); }
//***************************************************************************** // //! Main function handling the I2C example //! //! \param None //! //! \return None //! //***************************************************************************** void main() { int iRetVal; char acCmdStore[512]; // // Initialize board configurations // BoardInit(); // // Configure the pinmux settings for the peripherals exercised // PinMuxConfig(); // // Configuring UART // InitTerm(); // // I2C Init // I2C_IF_Open(I2C_MASTER_MODE_FST); // // Display the banner followed by the usage description // DisplayBanner(APP_NAME); DisplayUsage(); while(FOREVER) { // // Provide a prompt for the user to enter a command // DisplayPrompt(); // // Get the user command line // iRetVal = GetCmd(acCmdStore, sizeof(acCmdStore)); if(iRetVal < 0) { // // Error in parsing the command as length is exceeded. // UART_PRINT("Command length exceeded 512 bytes \n\r"); DisplayUsage(); } else if(iRetVal == 0) { // // No input. Just an enter pressed probably. Display a prompt. // } else { // // Parse the user command and try to process it. // iRetVal = ParseNProcessCmd(acCmdStore); if(iRetVal < 0) { UART_PRINT("Error in processing command\n\r"); DisplayUsage(); } } } }
int main ( int argc, char *argv[]) { char *Filename; int Status; int j; printf (ACPI_COMMON_SIGNON ("ACPI Binary Table Extraction Utility")); if (argc < 2) { DisplayUsage (); return (0); } /* Command line options */ while ((j = AcpiGetopt (argc, argv, "ahls:")) != EOF) switch (j) { case 'a': AxAction = AX_EXTRACT_ALL; /* Extract all tables found */ break; case 'l': AxAction = AX_LIST_ALL; /* List tables only, do not extract */ break; case 's': AxAction = AX_EXTRACT_SIGNATURE; /* Extract only tables with this sig */ break; case 'h': default: DisplayUsage (); return (0); } /* Input filename is always required */ Filename = argv[AcpiGbl_Optind]; if (!Filename) { printf ("Missing required input filename\n"); return (-1); } /* Perform requested action */ switch (AxAction) { case AX_EXTRACT_ALL: Status = AxExtractTables (Filename, NULL, AX_OPTIONAL_TABLES); break; case AX_LIST_ALL: Status = AxListTables (Filename); break; case AX_EXTRACT_SIGNATURE: Status = AxExtractTables (Filename, AcpiGbl_Optarg, AX_REQUIRED_TABLE); break; default: /* * Default output is the DSDT and all SSDTs. One DSDT is required, * any SSDTs are optional. */ Status = AxExtractTables (Filename, "DSDT", AX_REQUIRED_TABLE); if (Status) { return (Status); } Status = AxExtractTables (Filename, "SSDT", AX_OPTIONAL_TABLES); break; } return (Status); }
static int ReadData(int socket_fd, uint8_t *buffer, uint32_t length, unsigned long timeout_ms) { ssize_t numread; unsigned total = 0; fd_set socket_fd_set; do { struct timeval tv = {.tv_sec = timeout_ms / 1000, .tv_usec = (timeout_ms % 1000)*1000}; FD_ZERO(&socket_fd_set); FD_SET(socket_fd,&socket_fd_set); const int select_result = select(socket_fd+1,&socket_fd_set,NULL,NULL,&tv); if(select_result <= 0) return -1; else if(select_result == 0) return 0; numread = read(socket_fd, buffer + total, length - total); if (!numread) return 0; else if (numread > 0) total += numread; else if (errno != EINTR && errno != EAGAIN) return -1; } while (total < length); if (total < length) return 0; return 1; } static int ReadResponse(int socket_fd, CSMessageHeader *hdr, int timeout_ms) { const int rc = ReadData(socket_fd,(uint8_t *)hdr,sizeof(*hdr),timeout_ms); if(rc > 0){ hdr->length = ntohl(hdr->length); hdr->version = ntohs(hdr->version); hdr->type = ntohs(hdr->type); } return rc; } static void ConnectToUnixSocket(const char * const name, int * const psock) { struct sockaddr_un sunaddr; int sock = -1; int rval; memset(&sunaddr, 0, sizeof(sunaddr)); rval = snprintf(sunaddr.sun_path, sizeof(sunaddr.sun_path), "%s", name); if (rval < 0 || (size_t)rval >= sizeof(sunaddr.sun_path)) { fprintf(stderr, "Socket name '%s' is too long\n", name); exit(-1); } sunaddr.sun_family = AF_UNIX; /* open the socket */ if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "Error opening socket: %s\n", strerror(errno)); exit(-1); } if (connect(sock, (struct sockaddr *) &sunaddr, sizeof(sunaddr)) == -1) { fprintf(stderr, "Unable to connect to UNIX socket at %s: %s\n", name, strerror(errno)); close(sock); exit(-1); } *psock = sock; } int main(int argc, char *argv[]) { int rval; char socket_fn[PATH_MAX]; int socket_fd; CSMessage *message; const unsigned long type = 1361; const char *sep; ssize_t len; PrintMode mode = PRINT_MODE_FAST; unsigned int timeout_ms = 0; if (argc != 4 || !*argv[1] || !*argv[2] || !*argv[3]) { DisplayUsage(argv[0]); exit(-1); } else if (argc > 2) { int idx = 2; if((strlen(TIMEOUT_KEYWORD) == strlen(argv[idx])) && (strcmp(TIMEOUT_KEYWORD,argv[idx]) == 0)) { mode = PRINT_MODE_FAST; idx ++; } if (argc > idx) { timeout_ms = atoi(argv[idx]); } } len = strlen(argv[1]); if (len && argv[1][len - 1] == '/') sep = ""; else sep = "/"; snprintf(socket_fn, sizeof(socket_fn), "%s%s%s", argv[1], sep, CONTROL_FILE); ConnectToUnixSocket(socket_fn, &socket_fd); message = malloc(sizeof *message); if (message == NULL) { fprintf(stderr, "%s: could not allocate message.\n",argv[0]); exit(-1); } message->hdr.version = htons(CS_HEADER_VERSION); message->hdr.type = htons((uint16_t)type); message->hdr.length = 0; if ((rval = SendMessage(socket_fd, message)) < 0) { fprintf(stderr, "Failed to send the message: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket\n"); close(socket_fd); exit(-1); } if ((rval = ReadResponse(socket_fd, &message->hdr,timeout_ms)) < 0) { fprintf(stderr, "Failed to read the response: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket before sending a response\n"); close(socket_fd); exit(-1); } if (message->hdr.version != CS_HEADER_VERSION) { printf("%s: bad response version\n",argv[0]); close(socket_fd); exit(-1); } if (message->hdr.type != 9) { printf("%s: bad response type:%d, expected %d",argv[0],message->hdr.type,9); close(socket_fd); exit(-1); } if (message->hdr.length) { if (message->hdr.length < sizeof(message->msg_hdr)) { printf("%s: response message is too small\n",argv[0]); close(socket_fd); exit(-1); } if (message->hdr.length > sizeof(message->msg)) { printf("%s: response message is too large\n",argv[0]); close(socket_fd); exit(-1); } if ((rval = ReadData(socket_fd, (uint8_t *)message+sizeof(message->hdr), message->hdr.length, timeout_ms)) < 0) { fprintf(stderr, "Failed to read the response data: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket before sending the response data\n"); close(socket_fd); exit(-1); } message->msg_hdr.code = ntohl(message->msg_hdr.code); message->msg_hdr.length = ntohs(message->msg_hdr.length); if (mode == PRINT_MODE_DETAIL) { fprintf(stdout, "Response %04X with code %d and length %u\n", message->hdr.type, message->msg_hdr.code, message->msg_hdr.length); DumpHex(stdout, message->msg, message->msg_hdr.length); } else if (mode == PRINT_MODE_FAST) { if (message->msg_hdr.length == message->hdr.length - sizeof(message->msg_hdr)) { message->msg[message->msg_hdr.length-1] = 0; fprintf(stdout, "Response %04X with code %d (%s)\n", message->hdr.type, message->msg_hdr.code, message->msg); } else fprintf(stdout, "Response %04X with code %d\n", message->hdr.type, message->msg_hdr.code); } } else { if (mode == PRINT_MODE_DETAIL) printf("Response %04X without data\n", message->hdr.type); else printf("Response %04X\n", message->hdr.type); } return 0; }
bool BMDConfig::ParseArguments(int argc, char** argv) { int ch; bool displayHelp = false; while ((ch = getopt(argc, argv, "d:?h3c:s:v:a:m:n:q:p:t:l:")) != -1) { switch (ch) { case 'd': m_deckLinkIndex = atoi(optarg); break; case 'm': m_displayModeIndex = atoi(optarg); break; case 'c': m_audioChannels = atoi(optarg); if (m_audioChannels != 2 && m_audioChannels != 8 && m_audioChannels != 16) { fprintf(stderr, "Invalid argument: Audio Channels must be either 2, 8 or 16\n"); return false; } break; case 's': m_audioSampleDepth = atoi(optarg); if (m_audioSampleDepth != 16 && m_audioSampleDepth != 32) { fprintf(stderr, "Invalid argument: Audio Sample Depth must be either 16 bits or 32 bits\n"); return false; } break; case 'v': m_videoOutputFile = optarg; break; case 'l': m_lcmChannelName = optarg; break; case 'a': m_audioOutputFile = optarg; break; case 'n': m_maxFrames = atoi(optarg); break; case 'q': m_compressionQuality = atoi(optarg); break; case '3': m_inputFlags |= bmdVideoInputDualStream3D; break; case 'p': switch(atoi(optarg)) { case 0: m_pixelFormat = bmdFormat8BitYUV; break; case 1: m_pixelFormat = bmdFormat10BitYUV; break; case 2: m_pixelFormat = bmdFormat10BitRGB; break; default: fprintf(stderr, "Invalid argument: Pixel format %d is not valid", atoi(optarg)); return false; } break; case 't': if (!strcmp(optarg, "rp188")) m_timecodeFormat = bmdTimecodeRP188Any; else if (!strcmp(optarg, "vitc")) m_timecodeFormat = bmdTimecodeVITC; else if (!strcmp(optarg, "serial")) m_timecodeFormat = bmdTimecodeSerial; else { fprintf(stderr, "Invalid argument: Timecode format \"%s\" is invalid\n", optarg); return false; } break; case '?': case 'h': displayHelp = true; } } if (m_deckLinkIndex < 0) { fprintf(stderr, "You must select a device\n"); DisplayUsage(1); } if (m_displayModeIndex < -1) { fprintf(stderr, "You must select a display mode\n"); DisplayUsage(1); } if (displayHelp) DisplayUsage(0); // Get device and display mode names IDeckLink* deckLink = GetDeckLink(m_deckLinkIndex); if (deckLink != NULL) { if (m_displayModeIndex != -1) { IDeckLinkDisplayMode* displayMode = GetDeckLinkDisplayMode(deckLink, m_displayModeIndex); if (displayMode != NULL) { displayMode->GetName((const char**)&m_displayModeName); displayMode->Release(); } else { m_displayModeName = strdup("Invalid"); } } else { m_displayModeName = strdup("Format Detection"); } deckLink->GetModelName((const char**)&m_deckLinkName); deckLink->Release(); } else { m_deckLinkName = strdup("Invalid"); } return true; }
int main(int argc, char *argv[]) { const char *input_name; const char *output_name; FILE *input_fd; FILE *output_fd; int x; /* Parse arguments. */ input_name = NULL; output_name = NULL; for(x = 1; x < argc; x++) { if(!strcmp(argv[x], "-o")) { if(output_name != NULL) { DisplayUsage(argv[0]); return -1; } else { output_name = argv[x + 1]; ++x; } } else if(!strcmp(argv[x], "-raw")) { output_format = OUT_RAW; } else if(!strcmp(argv[x], "-list")) { output_format = OUT_LISTING; } else if(!strcmp(argv[x], "-hex")) { output_format = OUT_HEX; } else if(!strcmp(argv[x], "-h")) { DisplayUsage(argv[0]); return 0; } else { if(input_name != NULL) { DisplayUsage(argv[0]); return -1; } else { input_name = argv[x]; } } } if(input_name == NULL) { DisplayUsage(argv[0]); return -1; } if(output_name == NULL) { switch(output_format) { case OUT_RAW: output_name = "out.raw"; break; case OUT_HEX: output_name = "out.hex"; break; default: output_name = "out.lst"; break; } } byte_count = 0; error_count = 0; symbols = NULL; macros = NULL; input_fd = DoPreprocess(input_name); if(input_fd != NULL) { DoFirstPass(input_fd); } if(error_count == 0) { output_fd = fopen(output_name, output_format == OUT_RAW ? "wb" : "w"); if(output_fd == NULL) { fclose(input_fd); fprintf(stderr, "ERROR: could not open %s for writing\n", output_name); return -1; } rewind(input_fd); DoSecondPass(input_fd, output_fd); fclose(output_fd); } if(input_fd) { fclose(input_fd); } printf("Errors: %u\n", error_count); printf("Byte count: %u\n", byte_count); return error_count; }
//-------------------------------------------------------------------------------------- // Parses the command line for parameters. See DXUTInit() for list //-------------------------------------------------------------------------------------- bool ParseCommandLine( SETTINGS* pSettings ) { bool bDisplayError = false; bool bDisplayHelp = false; WCHAR* strCmdLine; WCHAR* strArg; int nNumArgs; WCHAR** pstrArgList = CommandLineToArgvW( GetCommandLine(), &nNumArgs ); for( int iArg=1; iArg<nNumArgs; iArg++ ) { strCmdLine = pstrArgList[iArg]; // Handle flag args if( *strCmdLine == L'/' || *strCmdLine == L'-' ) { strCmdLine++; if( IsNextArg( strCmdLine, L"y" ) ) { pSettings->bOverwrite = true; continue; } if( IsNextArg( strCmdLine, L"t" ) ) { pSettings->bGenTangents = true; continue; } if( IsNextArg( strCmdLine, L"tb" ) ) { pSettings->bGenTangents = true; pSettings->bGenBinormals = true; continue; } if( IsNextArg( strCmdLine, L"a" ) ) { pSettings->bRetainAnimation = true; continue; } if( IsNextArg( strCmdLine, L"v" ) ) { pSettings->bVerbose = true; continue; } if( IsNextArg( strCmdLine, L"xt" ) ) { pSettings->outputType = MESH_TYPE_X_TEXT; continue; } if( IsNextArg( strCmdLine, L"x" ) ) { pSettings->outputType = MESH_TYPE_X_BINARY; continue; } if( IsNextArg( strCmdLine, L"sdkmesh" ) ) { pSettings->outputType = MESH_TYPE_SDKMESH; continue; } if( IsNextArg( strCmdLine, L"o" ) ) { if( iArg+1 < nNumArgs ) { strArg = pstrArgList[++iArg]; pSettings->bOutputFileProvided = true; StringCchCopy( pSettings->strOutputFile, 256, strArg ); continue; } wprintf( L"Incorrect flag usage: /o\n" ); bDisplayError = true; continue; } if( IsNextArg( strCmdLine, L"?" ) ) { DisplayUsage(); return false; } // Unrecognized flag wprintf( L"Unrecognized or incorrect flag usage: %s\n", strCmdLine ); bDisplayError = true; } else { // Handle non-flag args as seperate input file if( pSettings->bInputFileProvided ) { wprintf( L"Too many input files provided: %s\n", strCmdLine ); bDisplayError = true; } else { pSettings->bInputFileProvided = true; StringCchCopy( pSettings->strInputFile, 256, strCmdLine ); continue; } } } if( !pSettings->bInputFileProvided ) bDisplayHelp = true; if( pSettings->bInputFileProvided && !pSettings->bOutputFileProvided ) { StringCchCopy( pSettings->strOutputFile, MAX_PATH, pSettings->strInputFile ); } if( bDisplayHelp ) { DisplayUsage(); return false; } if( bDisplayError ) { wprintf( L"Type \"MeshConvert.exe /?\" for a complete list of options\n" ); return false; } return true; }
main (int argc, char *argv[]) { char *gpdfile; char *option; bool verbose; grid_class *grid_def; /* * set defaults */ verbose = FALSE; /* * get command line options */ while (--argc > 0 && (*++argv)[0] == '-') { for (option = argv[0]+1; *option != '\0'; option++) { switch (*option) { case 'v': verbose = TRUE; break; default: fprintf(stderr,"invalid option %c\n", *option); DisplayUsage(); } } } /* * get command line arguments */ if (argc != 1) DisplayUsage(); gpdfile = *argv++; if (verbose) { fprintf(stderr, "gridsize:\n"); fprintf(stderr, " gpdfile = %s\n", gpdfile); fprintf(stderr, " gridsize_c_rcsid = %s\n", gridsize_c_rcsid); } /* * initialize grid */ grid_def = init_grid(gpdfile); if (NULL == grid_def) { /* * if grid has error, then print zeroes and exit with failure */ printf("cols: 0\n"); printf("rows: 0\n"); exit(ABORT); } else { /* * if grid is ok, then print number of columns and rows */ printf("cols: %d\n", grid_def->cols); printf("rows: %d\n", grid_def->rows); /* * close grid */ close_grid(grid_def); } exit(EXIT_SUCCESS); }
main (int argc, char *argv[]) { bool verbose; bool very_verbose; bool exponential; bool ignore; bool temp_mode; char *option; char *gpdfile; int col_start; int row_start; int cols; int rows; char *corfile; bool do_correction; char line[MAX_STRING]; int count_input; int count_output; double col; double row; double elev; double temperature; float lat; float lon; grid_class *grid_def; int status; int bytes_per_cell; int bytes_per_row; float **correction; int jcol; int irow; FILE *fp_cor; bool in_region; /* * set defaults */ verbose = FALSE; very_verbose = FALSE; exponential = FALSE; ignore = FALSE; gpdfile = "Sa0.gpd"; do_correction = FALSE; temp_mode = 0; /* * get command line options */ while (--argc > 0 && (*++argv)[0] == '-') { for (option = argv[0]+1; *option != '\0'; option++) { switch (*option) { case 'v': if (verbose) very_verbose = TRUE; verbose = TRUE; break; case 'e': exponential = TRUE; break; case 'i': ignore = TRUE; break; case 'g': ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("gpdfile"); gpdfile = *argv; break; case 'c': do_correction = TRUE; ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("col_start"); if (sscanf(*argv, "%d", &col_start) != 1) DisplayInvalidParameter("col_start"); ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("row_start"); if (sscanf(*argv, "%d", &row_start) != 1) DisplayInvalidParameter("row_start"); ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("cols"); if (sscanf(*argv, "%d", &cols) != 1) DisplayInvalidParameter("cols"); ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("rows"); if (sscanf(*argv, "%d", &rows) != 1) DisplayInvalidParameter("rows"); ++argv; --argc; if (argc <= 0) DisplayInvalidParameter("corfile"); corfile = *argv; break; case 't': temp_mode = TRUE; break; default: fprintf(stderr,"invalid option %c\n", *option); DisplayUsage(); } } } /* * get command line arguments */ if (argc != 0) DisplayUsage(); if (verbose) { fprintf(stderr, "lle2cre: %s\n", lle2cre_c_rcsid); fprintf(stderr, " very_verbose = %d\n", very_verbose); fprintf(stderr, " exponential = %d\n", exponential); fprintf(stderr, " ignore = %d\n", ignore); fprintf(stderr, " gpdfile = %s\n", gpdfile); if (do_correction) { fprintf(stderr, " col_start = %d\n", col_start); fprintf(stderr, " row_start = %d\n", row_start); fprintf(stderr, " cols = %d\n", cols); fprintf(stderr, " rows = %d\n", rows); fprintf(stderr, " corfile = %s\n", corfile); } fprintf(stderr, " temp_mode = %d\n", temp_mode); } /* * initialize grid */ grid_def = init_grid(gpdfile); if (NULL == grid_def) exit(ABORT); if (do_correction) { /* * allocate memory for correction */ bytes_per_cell = sizeof(float); if ((correction = (float **)matrix(rows, cols, bytes_per_cell, 1)) == NULL) { fprintf(stderr, "cr2cre: error allocating memory for correction"); perror("lle2cre"); error_exit("lle2cre"); } /* * read in entire correction */ if ((fp_cor = fopen(corfile, "r")) == NULL) { fprintf(stderr, "lle2cre: error opening %s\n", corfile); perror("lle2cre"); error_exit("lle2cre"); } bytes_per_row = bytes_per_cell * cols; if (fread(&correction[0][0], bytes_per_row, rows, fp_cor) != rows) { fprintf(stderr, "lle2cre: error reading %s\n", corfile); perror("lle2cre"); error_exit("lle2cre"); } fclose(fp_cor); } count_input = 0; count_output = 0; while (fgets(line, sizeof(line), stdin)) { /* * read and parse input line */ count_input++; if (sscanf(line, "%f%f%lf", &lat, &lon, &elev) != 3) { fprintf(stderr, "error parsing input line %d:\n%s\n", count_input, line); } else { if (temp_mode) { temperature = elev; elev = 0.0; } /* * convert lat-lon pair to col-row pair */ in_region = TRUE; status = forward_grid(grid_def, lat, lon, &col, &row); if (status == 0) { if (very_verbose || !ignore) { fprintf(stderr, "Error mapping lat-lon to col-row on line %d:\n", count_input); fprintf(stderr, " %s\n", line); } if (ignore) in_region = FALSE; } /* * perform correction as needed */ if (do_correction) { irow = (int)(row - row_start + 0.5); jcol = (int)(col - col_start + 0.5); if (irow >= 0 && irow < rows && jcol >= 0 && jcol < cols) { elev += correction[irow][jcol]; } else { in_region = FALSE; } } /* * write output line */ if (in_region) { if (temp_mode) if (exponential) printf("%15.8le %15.8le %15.8le %15.8le\n", col, row, elev, temperature); else printf("%11.5lf %11.5lf %11.6lf %11.5lf\n", col, row, elev, temperature); else if (exponential) printf("%15.8le %15.8le %15.8le\n", col, row, elev); else printf("%11.5lf %11.5lf %11.6lf\n", col, row, elev); count_output++; } } } /* * close grid */ close_grid(grid_def); /* * deallocate memory for correction */ if (do_correction) free(correction); /* * print number of lines processed */ if (verbose) { fprintf(stderr, " %d lines input\n", count_input); fprintf(stderr, " %d lines output\n", count_output); } exit(EXIT_SUCCESS); }
static void DisplayInvalidParameter(char *param) { fprintf(stderr, "lle2cre: Parameter %s is invalid.\n", param); DisplayUsage(); }
static void ProcessArgs(void) { int i = 1; int count = 0; char *text; char option; while(i < ArgCount) { text = ArgVector[i]; if(*text == '-') { // Option text++; if(*text == 0) { DisplayUsage(); } option = toupper(*text++); switch(option) { case 'I': if((i + 1) < ArgCount) { TK_AddIncludePath(ArgVector[++i]); } break; case 'D': acs_DebugMode = YES; acs_VerboseMode = YES; if(*text != 0) { OpenDebugFile(text); } break; case 'H': pc_NoShrink = TRUE; pc_HexenCase = TRUE; pc_EnforceHexen = toupper(*text) != 'H'; pc_WarnNotHexen = toupper(*text) == 'H'; break; default: DisplayUsage(); break; } } else { // Input/output file count++; switch(count) { case 1: strcpy(acs_SourceFileName, text); MS_SuggestFileExt(acs_SourceFileName, ".acs"); break; case 2: strcpy(ObjectFileName, text); MS_SuggestFileExt(ObjectFileName, ".o"); break; default: DisplayUsage(); break; } } // Next arg i++; } if(count == 0) { DisplayUsage(); } TK_AddIncludePath("."); #ifdef unix TK_AddIncludePath("/usr/local/share/acc/"); #endif TK_AddProgramIncludePath(ArgVector[0]); if(count == 1) { strcpy(ObjectFileName, acs_SourceFileName); MS_StripFileExt(ObjectFileName); MS_SuggestFileExt(ObjectFileName, ".o"); } }
extern "C" int __stdcall WinMain(HINSTANCE hInst, HINSTANCE hPrevInst , __in LPSTR lpszCmdLine, int nCmdShow) { //----------------------------------------------------------------------------------------------------------------- // VARIABLES // //----------------------------------------------------------------------------------------------------------------- UINT uiRet = ERROR_SUCCESS; HRESULT hr = S_OK; char *szMsiFile = 0; char *szBaseURL = 0; char *szInstallPath = 0; char *szMsiCacheFile = 0; char *szOperation = 0; char *szProductName = 0; char *szMinimumMsi = 0; char *szProperties = 0; char *szInstProperties = 0; char *szTempPath = 0; char *szFilePart = 0; char *szBase = 0; char *szUpdate = 0; char *szRegisteredMsiFolder = 0; char *szMsiDllLocation = 0; char szAppTitle[MAX_STR_CAPTION] = {0}; char szError[MAX_STR_LENGTH] = {0}; char szText[MAX_STR_CAPTION] = {0}; char szBanner[MAX_STR_LENGTH] = {0}; char szAction[MAX_STR_LENGTH] = {0}; char szUserPrompt[MAX_STR_LENGTH] = {0}; char szProductCode[MAX_LENGTH_GUID] = {0}; char szModuleFile[MAX_PATH] = {0}; DWORD dwModuleFileSize = MAX_PATH; DWORD dwMsiFileSize = 0; DWORD dwBaseURLSize = 0; DWORD cchInstallPath = 0; DWORD dwMsiCacheFileSize = 0; DWORD dwOperationSize = 0; DWORD dwProductNameSize = 0; DWORD dwMinimumMsiSize = 0; DWORD dwPropertiesSize = 0; DWORD cchInstProperties = 0; DWORD cchTempPath = 0; DWORD dwLastError = 0; DWORD cchReturn = 0; DWORD dwBaseUpdateSize = 0; DWORD dwUpdateSize = 0; DWORD dwResult = 0; DWORD dwType = 0; DWORD dwProductCodeSize = MAX_LENGTH_GUID; DWORD dwRegisteredMsiFolderSize = 0; DWORD dwMsiDllLocationSize = 0; ULONG ulMsiMinVer = 0; char *szStopScan = NULL; bool fDelayRebootReq = false; bool fPatch = false; bool fQFE = false; bool fOSSupported = false; emEnum emExecMode = emPreset; HKEY hInstallerKey = 0; HMODULE hMsi = 0; PFnMsiSetInternalUI pfnMsiSetInternalUI = 0; PFnMsiInstallProduct pfnMsiInstallProduct = 0; PFnMsiApplyPatch pfnMsiApplyPatch = 0; PFnMsiReinstallProduct pfnMsiReinstallProduct = 0; PFnMsiQueryProductState pfnMsiQueryProductState = 0; PFnMsiOpenDatabase pfnMsiOpenDatabase = 0; PFnMsiDatabaseOpenView pfnMsiDatabaseOpenView = 0; PFnMsiViewExecute pfnMsiViewExecute = 0; PFnMsiViewFetch pfnMsiViewFetch = 0; PFnMsiRecordGetString pfnMsiRecordGetString = 0; PFnMsiCloseHandle pfnMsiCloseHandle = 0; MSIHANDLE hDatabase = 0; MSIHANDLE hView = 0; MSIHANDLE hRec = 0; INSTALLSTATE isProduct = INSTALLSTATE_UNKNOWN; const char * szAdminImagePath = 0; //----------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------- // create our UI object CDownloadUI DownloadUI; // Load our AppTitle (caption) WIN::LoadString(hInst, IDS_APP_TITLE, szAppTitle, sizeof(szAppTitle)/sizeof(char)); // Obtain path we are running from if (0 == WIN::GetModuleFileName(hInst, szModuleFile, dwModuleFileSize)) { // No UI displayed. Silent failure. uiRet = GetLastError(); goto CleanUp; } DebugMsg("[Info] we are running from --> %s\n", szModuleFile); // Figure out what we want to do emExecMode = GetExecutionMode (lpszCmdLine); if (emVerify == emExecMode) { // // We don't want any UI to be displayed in this case. The return value // from the exe is the result of the verification. Therefore, this // should be done before initializing the UI. // uiRet = VerifyFileSignature (szModuleFile, lpszCmdLine); if (ERROR_BAD_ARGUMENTS != uiRet) goto CleanUp; } if (ERROR_BAD_ARGUMENTS == uiRet || emHelp == emExecMode) { DisplayUsage(hInst, NULL, szAppTitle); goto CleanUp; } // // NOTE: // Delay handling admin. installs until we have determined if we are // patching an existing install or if we are doing a default install. // // initialize our UI object with desktop as parent DownloadUI.Initialize(hInst, /* hwndParent = */ 0, szAppTitle); // Check if we are installing on an OS that supports Windows Installer 3.0 fOSSupported = IsOSSupported(); if(!fOSSupported) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_OS_NOT_SUPPORTED); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } HANDLE hMutex = 0; // only run one instance at a time if (AlreadyInProgress(hMutex)) { // silently return - correct return code ? uiRet = ERROR_INSTALL_ALREADY_RUNNING; goto CleanUp; } // determine operation, default (if not present) is INSTALL if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_OPERATION, &szOperation, dwOperationSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } if (ERROR_SUCCESS != uiRet) { // set operation to default which is install if (szOperation) delete [] szOperation; szOperation = new char[lstrlen(szDefaultOperation) + 1]; if (!szOperation) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } if (FAILED(StringCchCopy(szOperation, lstrlen(szDefaultOperation) + 1, szDefaultOperation))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } // obtain name of product if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_PRODUCTNAME, &szProductName, dwProductNameSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } if (ERROR_SUCCESS != uiRet) { // use default if (szProductName) delete [] szProductName; szProductName = new char[MAX_STR_CAPTION]; if (!szProductName) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } WIN::LoadString(hInst, IDS_DEFAULT_PRODUCT, szProductName, MAX_STR_CAPTION); } // set banner text WIN::LoadString(hInst, IDS_BANNER_TEXT, szText, MAX_STR_CAPTION); StringCchPrintf(szBanner, sizeof(szBanner), szText, szProductName); if (irmCancel == DownloadUI.SetBannerText(szBanner)) { ReportUserCancelled(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_INSTALL_USEREXIT; goto CleanUp; } // Determine if this is a patch or a normal install. if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_DATABASE, &szMsiFile, dwMsiFileSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS != uiRet) { // look for patch if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_PATCH, &szMsiFile, dwMsiFileSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS != uiRet) { PostResourceNotFoundError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, ISETUPPROPNAME_DATABASE); goto CleanUp; } fPatch = true; } // // If we are here, this is either an admin. install or a default install. // File signature verification, help and other invalid parameters have // already been taken care of above. // if (emAdminInstall == emExecMode) { uiRet = GetAdminInstallInfo (fPatch, lpszCmdLine, &szAdminImagePath); if (ERROR_BAD_ARGUMENTS == uiRet) { DisplayUsage(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } } // // At this point, the validation of the commandline arguments is complete // and we have all the information we need. // // obtain minimum required MSI version if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_MINIMUM_MSI, &szMinimumMsi, dwMinimumMsiSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS != uiRet) { PostResourceNotFoundError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, ISETUPPROPNAME_MINIMUM_MSI); goto CleanUp; } // make sure required Msi version is a valid value -- must be >= 150 ulMsiMinVer = strtoul(szMinimumMsi, &szStopScan, 10); if (!szStopScan || (szStopScan == szMinimumMsi) || (*szStopScan != 0) || ulMsiMinVer < MINIMUM_SUPPORTED_MSI_VERSION) { // invalid minimum version string PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_VER_STR, szMinimumMsi, MINIMUM_SUPPORTED_MSI_VERSION); uiRet = ERROR_INVALID_PARAMETER; goto CleanUp; } DebugMsg("[Resource] Minimum Msi Value = %d\n", ulMsiMinVer); // compare minimum required MSI version to that which is on the machine if (IsMsiUpgradeNecessary(ulMsiMinVer)) { DebugMsg("[Info] Upgrade of Windows Installer is requested\n"); // make sure this is admin -- must have admin priviledges to upgrade Windows Installer if (!IsAdmin()) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_REQUIRES_ADMIN_PRIV); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } // Ask the user if they want to upgrade the installer WIN::LoadString(hInst, IDS_ALLOW_MSI_UPDATE, szUserPrompt, MAX_STR_LENGTH); if (IDYES != WIN::MessageBox(DownloadUI.GetCurrentWindow(), szUserPrompt, szAppTitle, MB_YESNO|MB_ICONQUESTION)) { // user decided to cancel ReportUserCancelled(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_INSTALL_USEREXIT; goto CleanUp; } if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_UPDATE, &szUpdate, dwUpdateSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS != uiRet) { PostResourceNotFoundError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, ISETUPPROPNAME_UPDATE); goto CleanUp; } // determine if we need to download the Windows Installer update package from the web -- based on presence of UPDATELOCATION property if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_UPDATELOCATION, &szBase, dwBaseUpdateSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS == uiRet) { // presence of UPDATELOCATION property indicates assumption of URL source if (ERROR_SUCCESS != (uiRet = DownloadAndUpgradeMsi(hInst, &DownloadUI, szAppTitle, szBase, szUpdate, szModuleFile, ulMsiMinVer))) { if (ERROR_SUCCESS_REBOOT_REQUIRED == uiRet) { // successful, but must reboot at end fDelayRebootReq = true; } else goto CleanUp; } } else { // lack of UPDATELOCATION property indicates assumption of Media source if (ERROR_SUCCESS != (uiRet = UpgradeMsi(hInst, &DownloadUI, szAppTitle, szModuleFile, szUpdate, ulMsiMinVer))) { if (ERROR_SUCCESS_REBOOT_REQUIRED == uiRet) { // successful, but must reboot at end fDelayRebootReq = true; } else goto CleanUp; } } } DebugMsg("[Info] Windows Installer has been upgraded, or was already correct version\n"); // perform some extra authoring validation if (fPatch && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szMinPatchOperation, -1) && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szMajPatchOperation, -1) && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szDefaultOperation, -1)) { // wrong operation DebugMsg("[Error] Operation %s is not valid for a patch\n", szOperation); PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_OPERATION, szOperation); uiRet = ERROR_INVALID_PARAMETER; goto CleanUp; } else if (!fPatch && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szInstallOperation, -1) && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szInstallUpdOperation, -1) && CSTR_EQUAL != CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szDefaultOperation, -1)) { // wrong operation DebugMsg("[Error] Operation %s is not valid for a package\n", szOperation); PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_OPERATION, szOperation); uiRet = ERROR_INVALID_PARAMETER; goto CleanUp; } // by now we either have a MSI or a MSP if (CSTR_EQUAL == CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szMinPatchOperation, -1) || CSTR_EQUAL == CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szInstallUpdOperation, -1) || (fPatch && CSTR_EQUAL == CompareString(lcidLOCALE_INVARIANT, NORM_IGNORECASE, szOperation, -1, szDefaultOperation, -1))) fQFE = true; // obtain base URL if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_BASEURL, &szBaseURL, dwBaseURLSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); goto CleanUp; } else if (ERROR_SUCCESS == uiRet) { // presence of BASEURL property indicates assumption of URL source . . . // generate the path to the installation package == baseURL + msiFile // note: msiFile is a relative path cchTempPath = lstrlen(szBaseURL) + lstrlen(szMsiFile) + 2; // 1 for slash, 1 for null szTempPath = new char[cchTempPath ]; if (!szTempPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } if (FAILED(StringCchCopy(szTempPath, cchTempPath, szBaseURL))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } // check for trailing slash on szBaseURL char *pch = szBaseURL + lstrlen(szBaseURL) + 1; // put at null terminator pch = CharPrev(szBaseURL, pch); if (*pch != '/') { if (FAILED(StringCchCat(szTempPath, cchTempPath, szUrlPathSep))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } if (FAILED(StringCchCat(szTempPath, cchTempPath, szMsiFile))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } // canocialize the URL path cchInstallPath = cchTempPath*2; szInstallPath = new char[cchInstallPath]; if (!szInstallPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } dwLastError = 0; // success if (!InternetCanonicalizeUrl(szTempPath, szInstallPath, &cchInstallPath, 0)) { dwLastError = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER == dwLastError) { // try again delete [] szInstallPath; szInstallPath = new char[cchInstallPath]; if (!szInstallPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } dwLastError = 0; // reset to success for 2nd attempt if (!InternetCanonicalizeUrl(szTempPath, szInstallPath, &cchInstallPath, 0)) dwLastError = GetLastError(); } } if (0 != dwLastError) { // error -- invalid path/Url PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_PATH, szTempPath); uiRet = dwLastError; goto CleanUp; } // set action text for download WIN::LoadString(hInst, IDS_DOWNLOADING_PACKAGE, szText, MAX_STR_CAPTION); StringCchPrintf(szAction, sizeof(szAction), szText, szMsiFile); if (irmCancel == DownloadUI.SetActionText(szAction)) { ReportUserCancelled(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_INSTALL_USEREXIT; goto CleanUp; } // download the msi file so we can attempt a trust check -- must be local for WinVerifyTrust DebugMsg("[Info] Downloading msi file %s for WinVerifyTrust check\n", szInstallPath); szMsiCacheFile = new char[MAX_PATH]; dwMsiCacheFileSize = MAX_PATH; if (!szMsiCacheFile) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } hr = WIN::URLDownloadToCacheFile(NULL, szInstallPath, szMsiCacheFile, dwMsiCacheFileSize, 0, /* IBindStatusCallback = */ &CDownloadBindStatusCallback(&DownloadUI)); if (DownloadUI.HasUserCanceled()) { ReportUserCancelled(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_INSTALL_USEREXIT; goto CleanUp; } if (FAILED(hr)) { // error during download -- probably because file not found (or lost connection) PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_NOMSI, szInstallPath); uiRet = ERROR_FILE_NOT_FOUND; goto CleanUp; } DebugMsg("[Info] Msi file was cached to %s\n", szMsiCacheFile); // set action text for trust verification WIN::LoadString(hInst, IDS_VALIDATING_SIGNATURE, szText, MAX_STR_CAPTION); StringCchPrintf(szAction, sizeof(szAction), szText, szMsiFile); if (irmCancel == DownloadUI.SetActionText(szAction)) { ReportUserCancelled(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_INSTALL_USEREXIT; goto CleanUp; } // perform trust check itvEnum itv = IsPackageTrusted(szModuleFile, szMsiCacheFile, DownloadUI.GetCurrentWindow()); if (itvWintrustNotOnMachine == itv) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_NO_WINTRUST); uiRet = ERROR_CALL_NOT_IMPLEMENTED; goto CleanUp; } else if (itvUnTrusted == itv) { PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_UNTRUSTED, szInstallPath); uiRet = HRESULT_CODE(TRUST_E_SUBJECT_NOT_TRUSTED); goto CleanUp; } } else { // lack of BASEURL property indicates assumption of Media source // generate the path to the Msi file = szModuleFile + msiFile // note: msiFile is a relative path cchTempPath = lstrlen(szModuleFile) + lstrlen(szMsiFile) + 2; // 1 for null terminator, 1 for back slash szTempPath = new char[cchTempPath]; if (!szTempPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } // find 'setup.exe' in the path so we can remove it if (0 == GetFullPathName(szModuleFile, cchTempPath, szTempPath, &szFilePart)) { uiRet = GetLastError(); PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_PATH, szTempPath); goto CleanUp; } if (szFilePart) *szFilePart = '\0'; if (FAILED(StringCchCat(szTempPath, cchTempPath, szMsiFile))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } cchInstallPath = 2*cchTempPath; szInstallPath = new char[cchInstallPath]; if (!szInstallPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } // normalize the path cchReturn = GetFullPathName(szTempPath, cchInstallPath, szInstallPath, &szFilePart); if (cchReturn > cchInstallPath) { // try again, with larger buffer delete [] szInstallPath; cchInstallPath = cchReturn; szInstallPath = new char[cchInstallPath]; if (!szInstallPath) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } cchReturn = GetFullPathName(szTempPath, cchInstallPath, szInstallPath, &szFilePart); } if (0 == cchReturn) { // error -- invalid path PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INVALID_PATH, szTempPath); uiRet = dwLastError; goto CleanUp; } // no download is necessary -- but we can check for the file's existence DWORD dwFileAttrib = GetFileAttributes(szInstallPath); if (0xFFFFFFFF == dwFileAttrib) { // package is missing PostFormattedError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_NOMSI, szInstallPath); uiRet = ERROR_FILE_NOT_FOUND; goto CleanUp; } } // // good to go -- terminate our UI and let the Windows Installer take over // // retrieve the optional command line PROPERTY = VALUE strings if available if (ERROR_OUTOFMEMORY == (uiRet = SetupLoadResourceString(hInst, ISETUPPROPNAME_PROPERTIES, &szProperties, dwPropertiesSize))) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } else if (ERROR_SUCCESS != uiRet) { // PROPERTY=VALUE pairs not specified if (szProperties) delete [] szProperties; szProperties = NULL; } DownloadUI.Terminate(); // // perform install // hMsi = LoadLibrary(MSI_DLL); if (hMsi) { pfnMsiSetInternalUI = (PFnMsiSetInternalUI)GetProcAddress(hMsi, MSIAPI_MsiSetInternalUI); pfnMsiInstallProduct = (PFnMsiInstallProduct)GetProcAddress(hMsi, MSIAPI_MsiInstallProduct); pfnMsiApplyPatch = (PFnMsiApplyPatch)GetProcAddress(hMsi, MSIAPI_MsiApplyPatch); pfnMsiReinstallProduct = (PFnMsiReinstallProduct)GetProcAddress(hMsi, MSIAPI_MsiReinstallProduct); pfnMsiQueryProductState = (PFnMsiQueryProductState)GetProcAddress(hMsi, MSIAPI_MsiQueryProductState); pfnMsiOpenDatabase = (PFnMsiOpenDatabase)GetProcAddress(hMsi, MSIAPI_MsiOpenDatabase); pfnMsiDatabaseOpenView = (PFnMsiDatabaseOpenView)GetProcAddress(hMsi, MSIAPI_MsiDatabaseOpenView); pfnMsiViewExecute = (PFnMsiViewExecute)GetProcAddress(hMsi, MSIAPI_MsiViewExecute); pfnMsiViewFetch = (PFnMsiViewFetch)GetProcAddress(hMsi, MSIAPI_MsiViewFetch); pfnMsiRecordGetString = (PFnMsiRecordGetString)GetProcAddress(hMsi, MSIAPI_MsiRecordGetString); pfnMsiCloseHandle = (PFnMsiCloseHandle)GetProcAddress(hMsi, MSIAPI_MsiCloseHandle); } if (!hMsi || !pfnMsiSetInternalUI || !pfnMsiInstallProduct || !pfnMsiApplyPatch || !pfnMsiReinstallProduct || !pfnMsiQueryProductState || !pfnMsiDatabaseOpenView || !pfnMsiViewExecute || !pfnMsiViewFetch || !pfnMsiRecordGetString || !pfnMsiCloseHandle) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_FAILED_TO_UPGRADE_MSI); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } DebugMsg("[Info] Setting Internal UI level to FULL...\n"); pfnMsiSetInternalUI(INSTALLUILEVEL_FULL, 0); if (!fPatch) { // performing install or reinstall/recache DebugMsg("[Info] Calling MsiInstallProduct with szInstallPath = %s", szInstallPath); DebugMsg(" and szCommandLine = %s\n", szProperties ? szProperties : "{null}"); // default operation for a package is INSTALL if (fQFE) { // check to see if this product is already installed if (ERROR_SUCCESS == pfnMsiOpenDatabase(szMsiCacheFile ? szMsiCacheFile : szInstallPath, MSIDBOPEN_READONLY, &hDatabase) && ERROR_SUCCESS == pfnMsiDatabaseOpenView(hDatabase, sqlProductCode, &hView) && ERROR_SUCCESS == pfnMsiViewExecute(hView, 0) && ERROR_SUCCESS == pfnMsiViewFetch(hView, &hRec) && ERROR_SUCCESS == pfnMsiRecordGetString(hRec, 1, szProductCode, &dwProductCodeSize)) { isProduct = pfnMsiQueryProductState(szProductCode); DebugMsg("[Info] MsiQueryProductState returned %d\n", isProduct); if (INSTALLSTATE_ADVERTISED != isProduct && INSTALLSTATE_DEFAULT != isProduct) { // product is unknown, so this will be a first time install DebugMsg("[Info] The product code '%s' is unknown. Will use first time install logic...\n", szProductCode); fQFE = false; } else { // product is known, use QFE syntax DebugMsg("[Info] The product code '%s' is known. Will use QFE recache and reinstall upgrade logic...\n", szProductCode); } } else { // some failure occurred when processing the product code, so treat as non-QFE DebugMsg("[Info] Unable to process product code. Will treat as first time install...\n"); fQFE = false; } if (hDatabase) pfnMsiCloseHandle(hDatabase); if (hView) pfnMsiCloseHandle(hView); if (hRec) pfnMsiCloseHandle(hRec); } // // Set up the properties to be passed into MSIInstallProduct // if (fQFE && !szProperties) cchInstProperties = lstrlen (szDefaultInstallUpdCommandLine); else if (szProperties) cchInstProperties = lstrlen (szProperties); if (emAdminInstall == emExecMode) cchInstProperties += lstrlen (szAdminInstallProperty); szInstProperties = new char[cchInstProperties + 1]; if (! szInstProperties) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } if (fQFE && !szProperties) { if (FAILED(StringCchCopy(szInstProperties, cchInstProperties + 1, szDefaultInstallUpdCommandLine))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } else if (szProperties) { if (FAILED(StringCchCopy(szInstProperties, cchInstProperties + 1, szProperties))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } else szInstProperties[0] = '\0'; if (emAdminInstall == emExecMode) { if (FAILED(StringCchCat(szInstProperties, cchInstProperties + 1, szAdminInstallProperty))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } uiRet = pfnMsiInstallProduct(szInstallPath, szInstProperties); if (ERROR_SUCCESS != uiRet) { // attempt to display an error message stored in msi.dll PostMsiError(hInst, hMsi, DownloadUI.GetCurrentWindow(), szAppTitle, uiRet); } DebugMsg("[Info] MsiInstallProduct returned %d\n", uiRet); } else { // default Operation for a patch is MINPATCH // if szProperties is NULL, use our default value for QFE patches if (!szProperties && fQFE) { DebugMsg("[Info] Patch is a MINPATCH (small or minor update patch) so using default command line '%s'\n", szDefaultMinPatchCommandLine); szProperties = new char[lstrlen(szDefaultMinPatchCommandLine) + 1]; if (!szProperties) { ReportErrorOutOfMemory(hInst, DownloadUI.GetCurrentWindow(), szAppTitle); uiRet = ERROR_OUTOFMEMORY; goto CleanUp; } if (FAILED(StringCchCopy(szProperties, lstrlen(szDefaultMinPatchCommandLine) + 1, szDefaultMinPatchCommandLine))) { PostError(hInst, DownloadUI.GetCurrentWindow(), szAppTitle, IDS_INTERNAL_ERROR); uiRet = ERROR_INSTALL_FAILURE; goto CleanUp; } } if (emAdminInstall == emExecMode) { // performing a patch DebugMsg("[Info] Calling MsiApplyPatch with szPatchPackage = %s", szMsiCacheFile); DebugMsg(" and szInstallPackage = %s and eInstallType = INSTALLTYPE_NETWORK_IMAGE", szAdminImagePath); DebugMsg(" and szCommandLine = %s\n", szProperties ? szProperties : "{null}"); uiRet = pfnMsiApplyPatch(szMsiCacheFile, szAdminImagePath, INSTALLTYPE_NETWORK_IMAGE, szProperties); } else { // performing a patch DebugMsg("[Info] Calling MsiApplyPatch with szPatchPackage = %s", szInstallPath); DebugMsg(" and szInstallPackage = {null} and eInstallType = INSTALLTYPE_DEFAULT"); DebugMsg(" and szCommandLine = %s\n", szProperties ? szProperties : "{null}"); uiRet = pfnMsiApplyPatch(szInstallPath, NULL, INSTALLTYPE_DEFAULT, szProperties); } if (ERROR_SUCCESS != uiRet) { // attempt to display an error message stored in msi.dll PostMsiError(hInst, hMsi, DownloadUI.GetCurrentWindow(), szAppTitle, uiRet); } DebugMsg("[Info] MsiApplyPatch returned %d\n", uiRet); } CleanUp: if (szMsiFile) delete [] szMsiFile; if (szBaseURL) delete [] szBaseURL; if (szInstallPath) delete [] szInstallPath; if (szMsiCacheFile) { WIN::DeleteUrlCacheEntry(szMsiCacheFile); delete [] szMsiCacheFile; } if (szProductName) delete [] szProductName; if (szMinimumMsi) delete [] szMinimumMsi; if (szProperties) delete [] szProperties; if (szTempPath) delete [] szTempPath; if (szBase) delete [] szBase; if (szUpdate) delete [] szUpdate; if (szRegisteredMsiFolder) delete [] szRegisteredMsiFolder; if (szMsiDllLocation) delete [] szMsiDllLocation; if (szOperation) delete [] szOperation; if(hMutex) CloseHandle(hMutex); if (hMsi) FreeLibrary(hMsi); DebugMsg("[Info] Setup exit code is %d\n", uiRet); if (fDelayRebootReq) { // need to reboot machine for updating Windows Installer WIN::LoadString(hInst, IDS_REBOOT_REQUIRED, szAction, MAX_STR_LENGTH); if (IDYES == MessageBox(NULL, szAction, szAppTitle, MB_YESNO|MB_ICONQUESTION)) { // must first aquire system shutdown privileges on NT/Win2K AcquireShutdownPrivilege(); // initiate system shutdown for reboot WIN::ExitWindowsEx(EWX_REBOOT, PCLEANUI | SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_INSTALLATION); } } return uiRet; }
int main ( int argc, char *argv[]) { char *Filename; int AxAction; int Status; int j; Gbl_TableCount = 0; Gbl_TableListHead = NULL; AxAction = AX_EXTRACT_AML_TABLES; /* Default: DSDT & SSDTs */ ACPI_DEBUG_INITIALIZE (); /* For debug version only */ AcpiOsInitialize (); printf (ACPI_COMMON_SIGNON (AX_UTILITY_NAME)); if (argc < 2) { DisplayUsage (); return (0); } /* Command line options */ while ((j = AcpiGetopt (argc, argv, AX_SUPPORTED_OPTIONS)) != ACPI_OPT_END) switch (j) { case 'a': AxAction = AX_EXTRACT_ALL; /* Extract all tables found */ break; case 'l': AxAction = AX_LIST_ALL; /* List tables only, do not extract */ break; case 'm': AxAction = AX_EXTRACT_MULTI_TABLE; /* Make single file for all DSDT/SSDTs */ break; case 's': AxAction = AX_EXTRACT_SIGNATURE; /* Extract only tables with this sig */ break; case 'v': /* -v: (Version): signon already emitted, just exit */ return (0); case 'h': default: DisplayUsage (); return (0); } /* Input filename is always required */ Filename = argv[AcpiGbl_Optind]; if (!Filename) { printf ("Missing required input filename\n"); return (-1); } /* Perform requested action */ switch (AxAction) { case AX_EXTRACT_ALL: Status = AxExtractTables (Filename, NULL, AX_OPTIONAL_TABLES); break; case AX_EXTRACT_MULTI_TABLE: Status = AxExtractToMultiAmlFile (Filename); break; case AX_LIST_ALL: Status = AxListTables (Filename); break; case AX_EXTRACT_SIGNATURE: Status = AxExtractTables (Filename, AcpiGbl_Optarg, AX_REQUIRED_TABLE); break; default: /* * Default output is the DSDT and all SSDTs. One DSDT is required, * any SSDTs are optional. */ Status = AxExtractTables (Filename, "DSDT", AX_REQUIRED_TABLE); if (Status) { return (Status); } Status = AxExtractTables (Filename, "SSDT", AX_OPTIONAL_TABLES); break; } return (Status); }
int main ( int argc, char *argv[]) { int Status; if (argc < 2) { DisplayUsage (); return (0); } if (argv[1][0] == '-') { if (argc < 3) { DisplayUsage (); return (0); } switch (argv[1][1]) { case 'a': /* Extract all tables found */ return (ExtractTables (argv[2], NULL, 0)); case 'l': /* List tables only, do not extract */ return (ListTables (argv[2])); case 's': /* Extract only tables with this signature */ return (ExtractTables (argv[2], &argv[1][2], 1)); default: DisplayUsage (); return (0); } } /* * Default output is the DSDT and all SSDTs. One DSDT is required, * any SSDTs are optional. */ Status = ExtractTables (argv[1], "DSDT", 1); if (Status) { return (Status); } Status = ExtractTables (argv[1], "SSDT", 0); return (Status); }
Options::Options (int argc, wchar_t** argv) : iVerboseFlag (false), iVersion (false), iHelpFlag (false), iExtractFilesFlag (false), iPauseOnExit (false), iList(false), iCreateECI(false) { while (--argc) { argv++; // WINDOWS ENVIRONMENT : If the underlying platform is WINDOWS then, // cope up with multiple arguments following the '-' or '/'. // // LINUX ENVIRONMENT : If the underlying platform is LINUX then, cope // up with multiple arguments following only the '-'. This restriction // of not dealing with arguments following '/' is due to the fact that, // the absolute paths in case of LINUX start with a '/'. So, this could // be mistaken as an option if we treat anything prefixed by a '/' as // an option. Hence, this facility is being removed once for all and // only '-' can(should) be used for specifying an option. if ( (**argv == '-') #ifndef __TOOLS2_LINUX__ || (**argv == '/') #endif ) { const wchar_t* optPtr = *argv; while (*++optPtr) { switch (*optPtr) { case 'd': case 'D': if (argc > 1) { argc--; iExtractDirectory = *(++argv); } else { throw ECmdLineNoDirArgument; } break; case 'h': case 'H': case '?': iHelpFlag = true; break; case 'v': case 'V': iVersion = true; break; case 'p': case 'P': iPauseOnExit = true; break; case 'i': case 'I': iVerboseFlag = true; break; case 'x': case 'X': iExtractFilesFlag = true; break; case 'l': case 'L': iList = true; break; case 'y': case 'Y': iCreateECI = true; break; default: throw ECmdLineUnknownOption; } } } else { if (iSISFileName != L"") { throw ECmdLineMultipleSIS; } else { iSISFileName = *argv; } } } if (iHelpFlag) { DisplayUsage (); if (iSISFileName == L"") // If we were asked for help then we shouldn't { // complain that there's no SIS file specified, exit (0); // just exit quietly. } } if (iVersion) { DisplayVersion (); if (iSISFileName == L"") { exit (0); } } if (iSISFileName == L"") { throw ECmdLineMissingSIS; } // Sanity check the directory argument // If directory name is not provided then // generate a directory name. GetExtractDir(); }
bool CCommandParser::ParseParam(int argc, const char**argv, CParameterList* aParamList) { if (argc < 2) { throw CCommandParser::ECmdLineUnknownOption; } bool bContinue = true; while ((--argc > 0) && bContinue) { ++argv; if (**argv != '-') { continue; } bool err = false; const char* optPtr = *argv; switch (toupper(*++optPtr)) { #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK case 'A': { if (argc <= 1) throw CCommandParser::ECmdLineNoDirArgument; --argc; aParamList->SetResourceFilePath(*(++argv)); break; } #endif //SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK case 'C': { if (argc <= 1) throw CCommandParser::ECmdLineNoDirArgument; --argc; aParamList->SetSystemDrive(*(++argv)); break; } case 'D': { --argc; wchar_t buf[2048]; ConvertMultiByteToWideChar(*++argv,-1, buf, 2048); aParamList->SetSystemDriveLetter(tolower(buf[0])); break; } case 'E': { aParamList->SetFlag(CParameterList::EFlagsDisableZDriveChecksSet); break; } #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK case 'F': { aParamList->SetOriginVerificationStatus(false); break; } #endif case 'H': case '?': { DisplayUsage(); bContinue = false; break; } case 'I': { if (argc <= 1) throw CCommandParser::ECmdLineNoConfigFileArgument; --argc; aParamList->SetConfigFile(*(++argv)); break; } case 'K': { // Last command if (argc == 1) { aParamList->SetSisRegistryVersion(SisRegistry::KRegistryV40string); } else { // Check that the next arg is valid std::string versionStr = *(++argv); if (**argv == '-') { aParamList->SetSisRegistryVersion(SisRegistry::KRegistryV40string); --argv; } else { --argc; aParamList->SetSisRegistryVersion(versionStr); } } break; } case 'L': { if (argc > 1) { --argc; wchar_t buf[2048]; ConvertMultiByteToWideChar(*++argv,-1, buf, 2048); iLogFile = buf; } break; } case 'N': { if (argc <= 1) throw CCommandParser::ECmdLineInvalidLanguage; --argc; aParamList->SetLanguage(static_cast< CSISLanguage::TLanguage >( String2Language( *(++argv) ) )); break; } case 'O': { DisplayOpenSSLCopyright(); bContinue = false; break; } case 'P': { if (!(err = argc <= 1)) { --argc; std::string paramFile = *(++argv); ParseParam(argc, paramFile, aParamList); } break; } case 'R': { if (argc <= 1) throw CCommandParser::ECmdLineNoRomRofsLogsArgument; --argc; aParamList->EmptyRomLogFiles(); #ifdef _MSC_VER FilePtr funtionPtr = aParamList->AddRomLogFile; #else FilePtr funtionPtr = &(aParamList->AddRomLogFile); #endif // _MSC_VER String2List(*aParamList, funtionPtr, *(++argv) ); break; } case 'S': { if (argc <= 1) throw CCommandParser::ECmdLineNoSisArgument; --argc; String2SISFileList(*aParamList, argc, ++argv); break; } case 'T': { if (argc <= 1) throw CCommandParser::ECmdLineNoSisStubPathArgument; --argc; aParamList->SetStubDir(*(++argv)); break; } case 'V': { DisplayVersion(); bContinue = false; break; } case 'W': { --argc; iWarnLevel = String2Warn(*(++argv)); break; } case 'X': { if (argc <= 1) throw CCommandParser::ECmdLineMissingPackageUID; --argc; aParamList->EmptyPkgUids(); #ifdef _MSC_VER FilePtr funtionPtr = (aParamList->AddPkgUid); #else FilePtr funtionPtr = &(aParamList->AddPkgUid); #endif // _MSC_VER String2List(*aParamList, funtionPtr, *(++argv) ); break; } case 'Z': { if (argc <= 1) throw CCommandParser::ECmdLineNoDirArgument; --argc; aParamList->SetZDrive(*(++argv)); break; } default: { LERROR(string2wstring(std::string(optPtr))); throw CCommandParser::ECmdLineUnknownOption; } } if (err) { throw CCommandParser::ECmdLineUnknownOption; } } // Finished parsing all the command line options return !bContinue; }
/* * ======== main ======== */ INT main(INT argc, CHAR * argv[]) { INT opt; bool fWaitForTerminate = false; UINT uProcId = 0; /* default proc ID is 0. */ bool fError = false; DSP_HPROCESSOR hProc; int status = 0; INT cArgc = 0; /* local argc count. */ bool fScriptable = false; extern char *optarg; struct DSP_PROCESSORINFO dspInfo; UINT numProcs; UINT index = 0; while ((opt = getopt(argc, argv, "+T+v+w+?p:")) != EOF) { switch (opt) { case 'v': /* verbose mode */ fprintf(stdout, "Verbose mode: ON\n"); g_fVerbose = true; cArgc++; break; case 'w': /* wait for user input to terminate */ fprintf(stdout, "Not supported \n"); fWaitForTerminate = true; cArgc++; break; case 'T': fScriptable = true; cArgc++; break; case 'p': /* user specified DSP processor ID (based on zero-index) */ uProcId = atoi(optarg); cArgc++; break; case '?': default: fError = true; break; } } argv += cArgc + 1; argc -= cArgc + 1; if (fError) { DisplayUsage(); } else { status = (DBAPI)DspManager_Open(ROOT_ACCESS, NULL); if (DSP_FAILED(status)) { PrintVerbose("DSPManager_Open failed \n"); return -1; } while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo, (UINT)sizeof(struct DSP_PROCESSORINFO),&numProcs))) { if ((dspInfo.uProcessorType == DSPTYPE_55) || (dspInfo.uProcessorType == DSPTYPE_64)) { printf("DSP device detected !! \n"); uProcId = index; status = 0; break; } index++; } status = DSPProcessor_Attach(uProcId, NULL, &hProc); if (DSP_SUCCEEDED(status)) { PrintVerbose("DSPProcessor_Attach succeeded.\n"); status = DSPProcessor_Stop(hProc); if (DSP_SUCCEEDED(status)) { PrintVerbose("DSPProcessor_Stop succeeded.\n"); status = DSPProcessor_Load(hProc,argc,(CONST CHAR **)argv,NULL); if (DSP_SUCCEEDED(status)) { PrintVerbose("DSPProcessor_Load succeeded.\n"); status = DSPProcessor_Start(hProc); if (DSP_SUCCEEDED(status)) { fprintf(stdout,"DSPProcessor_Start succeeded.\n"); #if 0 /* It seems Linux bridge does n't yet support * * DSPProcessor_GetTrace */ if (fWaitForTerminate) { /* wait for user */ fprintf(stdout,"Hit \"return\" to stop DSP and" "dump trace buffer:\n"); (void)getchar(); status = DSPProcessor_GetTrace(hProc, (BYTE *)&traceBuf,MAXTRACESIZE); fprintf(stdout,"%s\n",traceBuf); } else { PrintVerbose("in run free mode...\n"); } #endif /* 0 */ } else { PrintVerbose("DSPProcessor_Start failed: 0x%x.\n", status); } } else { PrintVerbose("DSPProcessor_Load failed: 0x%x.\n",status); } DSPProcessor_Detach(hProc); } } else { PrintVerbose("DSPProcessor_Attach failed: 0x%x.\n",status); } } if (!fScriptable) { /* Wait for user to hit any key before exiting. */ fprintf(stdout, "Hit any key to terminate cexec.\n"); (void)getchar(); } status = DspManager_Close(0, NULL); if (DSP_FAILED(status)) { printf("\nERROR: DSPManager Close FAILED\n"); } return (DSP_SUCCEEDED(status) ? 0 : -1); }
int main(int argc, char *argv[]) { int rval; char socket_fn[PATH_MAX]; int socket_fd; char *p; CSMessage *message; unsigned long type; const char *sep; ssize_t len; PrintMode mode = PRINT_MODE_DETAIL; const char *extra; unsigned int extra_len = 0; if (argc < 3 || argc > 5 || !*argv[1] || !*argv[2]) { DisplayUsage(argv[0]); exit(-1); } else if (argc > 3) { int idx = 3; if((strlen(PRINT_MODE_FAST_KEYWORD) == strlen(argv[idx])) && (strcmp(PRINT_MODE_FAST_KEYWORD,argv[idx]) == 0)) { mode = PRINT_MODE_FAST; idx ++; } if (argc > idx) { extra = argv[idx]; extra_len = strlen(extra) + 1; } } type = strtoul(argv[2], &p, 0); if (*p || type > CS_TYPE_MAX) { DisplayUsage(argv[0]); exit(-1); } len = strlen(argv[1]); if (len && argv[1][len - 1] == '/') sep = ""; else sep = "/"; snprintf(socket_fn, sizeof(socket_fn), "%s%s%s", argv[1], sep, CONTROL_FILE); ConnectToUnixSocket(socket_fn, &socket_fd); if (extra_len > sizeof(message->msg)) { fprintf(stderr, "snort_control: message is too long.\n"); exit(-1); } message = malloc(sizeof *message); if (message == NULL) { fprintf(stderr, "snort_control: could not allocate message.\n"); exit(-1); } message->hdr.version = htons(CS_HEADER_VERSION); message->hdr.type = htons((uint16_t)type); message->hdr.length = 0; if (extra_len) { message->hdr.length = htonl(extra_len + sizeof(message->msg_hdr)); message->msg_hdr.code = 0; message->msg_hdr.length = htons(extra_len); memcpy(message->msg, extra, extra_len); } if ((rval = SendMessage(socket_fd, message, extra_len)) < 0) { fprintf(stderr, "Failed to send the message: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket\n"); close(socket_fd); exit(-1); } do { /* Reusing the same CSMessage to capture the response */ if ((rval = ReadResponse(socket_fd, &message->hdr)) < 0) { fprintf(stderr, "Failed to read the response: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket before sending a response\n"); close(socket_fd); exit(-1); } if (message->hdr.version != CS_HEADER_VERSION) { printf("snort_control: bad response version\n"); close(socket_fd); exit(-1); } if (message->hdr.length) { if (message->hdr.length < sizeof(message->msg_hdr)) { printf("snort_control: response message is too small\n"); close(socket_fd); exit(-1); } if (message->hdr.length > sizeof(message->msg)) { printf("snort_control: response message is too large\n"); close(socket_fd); exit(-1); } if ((rval = ReadData(socket_fd, (uint8_t *)message+sizeof(message->hdr), message->hdr.length)) < 0) { fprintf(stderr, "Failed to read the response data: %s\n", strerror(errno)); close(socket_fd); exit(-1); } else if (!rval) { fprintf(stderr, "Server closed the socket before sending the response data\n"); close(socket_fd); exit(-1); } message->msg_hdr.code = ntohl(message->msg_hdr.code); message->msg_hdr.length = ntohs(message->msg_hdr.length); if (mode == PRINT_MODE_DETAIL) { fprintf(stdout, "Response %04X with code %d and length %u\n", message->hdr.type, message->msg_hdr.code, message->msg_hdr.length); DumpHex(stdout, message->msg, message->msg_hdr.length); } else if (mode == PRINT_MODE_FAST) { if (message->msg_hdr.length == message->hdr.length - sizeof(message->msg_hdr)) { message->msg[message->msg_hdr.length-1] = 0; fprintf(stdout, "Response %04X with code %d (%s)\n", message->hdr.type, message->msg_hdr.code, message->msg); } else fprintf(stdout, "Response %04X with code %d\n", message->hdr.type, message->msg_hdr.code); } } else { if (mode == PRINT_MODE_DETAIL) printf("Response %04X without data\n", message->hdr.type); else printf("Response %04X\n", message->hdr.type); } } while (message->hdr.type == CS_HEADER_DATA); return 0; }
//----------------------------------------------------------------------------- // Name: main() // Desc: Entry point for the application. We use just the console window //----------------------------------------------------------------------------- int main(int argc, char* argv[]) { // Enable run-time memory check for debug builds. #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif int nRet = 0; IDirect3DDevice9* pd3dDevice = NULL; SETTINGS settings; ZeroMemory( &settings, sizeof(SETTINGS) ); if( argc < 2 ) { DisplayUsage(); goto LCleanup; } if( !ParseCommandLine( &settings ) ) { nRet = 0; goto LCleanup; } if( settings.bVerbose ) { wprintf( L"Input file: %s\n", settings.strInputFile ); wprintf( L"Output file: %s\n", settings.strOutputFile ); wprintf( L"Overwrite: %d\n", settings.bOverwrite ); switch( settings.outputType ) { case MESH_TYPE_X_TEXT: wprintf( L"Output format: .x text\n" ); break; case MESH_TYPE_X_BINARY: wprintf( L"Output format: .x binary\n" ); break; case MESH_TYPE_SDKMESH: wprintf( L"Output format: sdkmesh\n" ); break; } } // Create NULLREF device pd3dDevice = CreateNULLRefDevice(); if( pd3dDevice == NULL ) { wprintf( L"Error: Can not create NULLREF Direct3D device\n" ); nRet = 1; goto LCleanup; } else { if( settings.bVerbose ) { wprintf( L"NULLREF Direct3D 9 device created\n" ); } // Load the mesh CLoader loader; if( FAILED(loader.Load( settings.strInputFile, FTT_RELATIVE )) ) { wprintf( L"Cannot Load specified input file\n" ); goto LCleanup; nRet = 1; } // Convert to Little Endian loader.GetMesh()->ConvertToLittleEndian(); // Create a decl that reflects our inputs D3DVERTEXELEMENT9 decl[MAX_VERTEX_ELEMENTS]; BuildVertexDecl( decl, &settings ); // Convert the mesh to this decl loader.GetMesh()->ConvertVertexData( pd3dDevice, decl, MAX_VERTEX_ELEMENTS ); // fix up the mesh loader.GetMesh()->FixMesh(); // if we need tangents or binormals, generate them if( settings.bGenTangents || settings.bGenBinormals ) { if( !loader.GetMesh()->GenerateTangents( pd3dDevice ) ) wprintf( L"Warning: Cannot generate tangent frame information for mesh\n" ); } // Save it out if( FAILED( loader.Save( pd3dDevice, settings.strOutputFile, settings.outputType ) ) ) { wprintf( L"Cannot Save specified output file\n" ); goto LCleanup; nRet = 1; } if( settings.bRetainAnimation ) { WCHAR szOutput[MAX_PATH]; StringCchCopy( szOutput, MAX_PATH, settings.strOutputFile ); StringCchCat( szOutput, MAX_PATH, L"_anim" ); if( FAILED( loader.SaveAnimationData( szOutput ) ) ) { wprintf( L"Cannot Save animation data\n" ); } } } LCleanup: wprintf( L"\n" ); #ifdef DEBUG_PRESSKEY wprintf( L"Press ENTER to continue."); _getch(); #endif // Cleanup SAFE_RELEASE( pd3dDevice ); return nRet; }