int main(int argc, char** argv) {
  if(!parseOption(argc, argv)) {
    fprintf(stderr, "failed to parse option\n");
    return 1;
  }

  BCCScriptRef script;

  if((script = loadScript()) == NULL) {
    fprintf(stderr, "failed to load source\n");
    return 2;
  }

#if 0
  if(printTypeInformation && !reflection(script, stderr)) {
    fprintf(stderr, "failed to retrieve type information\n");
    return 3;
  }
#endif

  printPragma(script);

  if(printListing && !disassemble(script, stderr)) {
    fprintf(stderr, "failed to disassemble\n");
    return 5;
  }

  if(runResults && !runMain(script, argc, argv)) {
    fprintf(stderr, "failed to execute\n");
    return 6;
  }

  return 0;
}
Beispiel #2
0
void parseMapOptions(
		std::vector<Option>& options,
		const std::string& fileName,
		const std::string& mapName,
		const std::string& fileModes,
		const std::string& accessModes,
		std::set<std::string>* optionsSet,
		CLogSubsystem* logSubsystem) {

	if (!logSubsystem) {
		assert(logSubsystem);
	}

	LuaParser luaParser(fileName, fileModes, accessModes);

	const string configName = MapParser::GetMapConfigName(mapName);
	const string mapFile    = archiveScanner->MapNameToMapFile(mapName);

	if (mapName.empty())
		throw "Missing map name!";

	if (configName.empty())
		throw "Couldn't determine config filename from the map name '" + mapName + "'!";

	luaParser.GetTable("Map");
	luaParser.AddString("name",     mapName);	
	luaParser.AddString("fileName", filesystem.GetFilename(mapFile));
	luaParser.AddString("fullName", mapFile);
	luaParser.AddString("configFile", configName);
	luaParser.EndTable();

	if (!luaParser.Execute()) {
		throw content_error("luaParser.Execute() failed: "
				+ luaParser.GetErrorLog());
	}

	const LuaTable root = luaParser.GetRoot();
	if (!root.IsValid()) {
		throw content_error("root table invalid");
	}

	std::set<std::string>* myOptionsSet = NULL;
	if (optionsSet == NULL) {
		myOptionsSet = new std::set<std::string>();
	} else {
		myOptionsSet = optionsSet;
	}
	for (int index = 1; root.KeyExists(index); index++) {
		Option opt;
		if (parseOption(root, index, opt, *myOptionsSet, *logSubsystem)) {
			options.push_back(opt);
		}
	}
	if (optionsSet == NULL) {
		delete myOptionsSet;
		myOptionsSet = NULL;
	}
}
Beispiel #3
0
bool ProtocolDHCP::dissect(const FrameBuffer& buffer, size_t& offset, Protocol::Ptr& next)
{
    if (!enoughFor(buffer, offset, sizeof (DHCPHeader))) {
        return false;
    }
    struct DHCPHeader * dhcp = (struct DHCPHeader*) (buffer.begin() + offset);
    _type = dhcp->type;
    _clientMAC = MAC(dhcp->macAddress);
    Poco::UInt32 ipAddress = ntohl(dhcp->ipYour);
    _assignedIP = Poco::Net::IPAddress(&ipAddress, sizeof (Poco::UInt32));
    offset += sizeof (struct DHCPHeader);
    bool more = parseOption(buffer, offset);
    while (more) {
        more = parseOption(buffer, offset);
    };
    next = nullptr;
    return true;
}
Beispiel #4
0
JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm, char *options, void *reserved) {
	jint rc;
	jvmtiEnv *jvmti;
	JNIEnv *jniEnv;
	jvmtiError err;


	char * optionType;
	char * otherOption = NULL;

	/* Get JVMTI environment */
	jvmti = NULL;
	rc = (*vm)->GetEnv(vm, (void **) &jvmti, JVMTI_VERSION);
	if (rc != JNI_OK) {
		ulog("ERROR: Unable to create jvmtiEnv, error=%d\n", rc);
		return JNI_ERR;
	}
	if (jvmti == NULL) {
		ulog("ERROR: No jvmtiEnv* returned from GetEnv\n");
		return JNI_ERR;
	}
	/////////////jni/////////////
	rc = (*vm)->GetEnv(vm, (void **) &jniEnv, JNI_VERSION_1_2);
	if (rc != JNI_OK) {
		ulog("ERROR: Unable to create jnienv, error=%d\n", rc);
		return JNI_ERR;
	}
	if (jvmti == NULL) {
		ulog("ERROR: No jnienv* returned from GetEnv\n");
		return JNI_ERR;
	}
	////////////////////////////
#ifdef DEBUG
	ulog("options: %s\n", options);
#endif

	parseOption(options, &optionType, &otherOption);

#ifdef DEBUG
	ulog("optionType:%s, otherOption: %s\n", optionType, otherOption==NULL?"":otherOption);
#endif


	if (strcmp(optionType, DUMP_REFER) == 0) {
		rc = printReferAction(jvmti, jniEnv, otherOption);
	} else if (strcmp(optionType, DUMP_ROOT) == 0) {
		rc = printRootReferAction(jvmti, otherOption);
	} else {
		rc = JNI_ERR;
		ulog("ERROR: invalid options\n");
	}

	err = (*jvmti)->DisposeEnvironment(jvmti);
	CHECK_ERROR_AND_RETURN(jvmti, err, "DisposeEnvironment error", JNI_ERR);

	return rc;
}
Beispiel #5
0
void parseOptions(
		std::vector<Option>& options,
		const std::string& fileName,
		const std::string& fileModes,
		const std::string& accessModes,
		const std::string& mapName,
		std::set<std::string>* optionsSet,
		CLogSubsystem* logSubsystem) {

	if (!logSubsystem) {
		assert(logSubsystem);
	}

	LuaParser luaParser(fileName, fileModes, accessModes);

	const string configName = MapParser::GetMapConfigName(mapName);

	if (!mapName.empty() && !configName.empty()) {
		luaParser.GetTable("Map");
		luaParser.AddString("fileName", mapName);
		luaParser.AddString("fullName", "maps/" + mapName);
		luaParser.AddString("configFile", configName);
		luaParser.EndTable();
	}

	if (!luaParser.Execute()) {
		throw content_error("luaParser.Execute() failed: "
				+ luaParser.GetErrorLog());
	}

	const LuaTable root = luaParser.GetRoot();
	if (!root.IsValid()) {
		throw content_error("root table invalid");
	}

	std::set<std::string>* myOptionsSet = NULL;
	if (optionsSet == NULL) {
		myOptionsSet = new std::set<std::string>();
	} else {
		myOptionsSet = optionsSet;
	}
	for (int index = 1; root.KeyExists(index); index++) {
		Option opt;
		if (parseOption(root, index, opt, *myOptionsSet, *logSubsystem)) {
			options.push_back(opt);
		}
	}
	if (optionsSet == NULL) {
		delete myOptionsSet;
		myOptionsSet = NULL;
	}
}
Beispiel #6
0
int main(int argc, char* argv[])
{
		if(argc!=7)
		{
				fprintf(stderr,"wrong argument. please input arguments like '-h 127.0.0.1 -p 6522 -f libsina.so\r\n");
				exit(-1);
		}
		parseOption(argc,argv);

		struct timeval timeout = { 1, 500 };
		redis_c = redisConnectWithTimeout(ip, port, timeout);
		if (redis_c->err) 
		{
				printf("Connection error: %s Port:%d\n", redis_c->errstr,port);
				exit(1);
		}
		char f_name[1024];
		sprintf(f_name,"./lib%s.so",fm_name);
		FILE *f =fopen(f_name,"r");
		char *p = malloc(FILEBUF);
		if(!p)
		{
				fprintf(stderr,"malloc failed.\r\n");
				exit(1);
		}
		int fsize = get_file_size(f_name);
		int len=0;
		int i;
		int ch;
		for(i =0;i<fsize; i++)
		{
				ch = fgetc(f);
				len += sprintf(p+len,"%d,",ch);
		}

		/*char *cmd ="{\"time\":1349688926,\
					\"ip\":\"127.0.0.1\",\
					\"script\":\"test.php\",\
					\"formula\":\"carsvm\",\
					\"programmer\":\"shunli\",\
					\"data\":{\
					\"tag\":\"qiche\",\
					\"parameter\":\"+1\t1:0.6\t2:0.3\"}}";
		*/
		reply = redisCommand(redis_c,"load %s %s",fm_name,p);
		freeReplyObject(reply);
		/*reply = redisCommand(redis_c,"grun aaa %s",cmd);
		freeReplyObject(reply);*/
		return 0;

}
Beispiel #7
0
int main(int argc, char *argv[]) {
	QtSingleApplication app("ac0452da134c2a204d7b5a7f5bb516147d27ee84", argc, argv);	// sha1(raptor)

	QStringList args = QCoreApplication::arguments();
	args.pop_front();
	
	QString message;
	foreach(QString arg, args){
		if(arg[0] == '-'){
			parseOption(arg);
			return 0;
		}else{
			QDir dir(arg);
			message += dir.absolutePath();
			message += ";";
		}
	}
	
	//check if raptor is already running
	if (app.isRunning()){
		//raptor is running, send full message
		app.sendMessage(message);
		//quit this instance of raptor
		return 0;
	}
	
	Settings settings;
	QLocale::Language language = settings.getTranslation();
	QString locale = QLocale(language).name();

	QTranslator raptorTranslator;
	if(raptorTranslator.load("raptor_" + locale, ApplicationPath::translationPath())){
		app.installTranslator(&raptorTranslator);
		QTranslator qtTranslator;
		if(qtTranslator.load("qt_" + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))){
			app.installTranslator(&qtTranslator);
		}
	}
	
	MainWindow mainWin;
	app.installEventFilter(&mainWin);

	mainWin.handleMessage(message);
	mainWin.show();

	app.setActivationWindow(&mainWin, false);
	QObject::connect(&app, SIGNAL(messageReceived(const QString&)), &mainWin, SLOT(handleMessage(const QString&)));

	return app.exec();
}
Beispiel #8
0
int main(int argc, char *argv[]) {
	const char *dataPath = "DATA";
	const char *savePath = ".";
	for (int i = 1; i < argc; ++i) {
		bool opt = false;
		if (strlen(argv[i]) >= 2) {
			opt |= parseOption(argv[i], "datapath=", &dataPath);
			opt |= parseOption(argv[i], "savepath=", &savePath);
		}
		if (!opt) {
			printf(USAGE);
			return 0;
		}
	}
	Version ver = detectVersion(dataPath);
	g_debugMask = DBG_INFO; // DBG_CUT | DBG_VIDEO | DBG_RES | DBG_MENU | DBG_PGE | DBG_GAME | DBG_UNPACK | DBG_COL | DBG_MOD | DBG_SFX;
	SystemStub *stub = SystemStub_SDL_create();
	Game *g = new Game(stub, dataPath, savePath, ver);
	g->run();
	delete g;
	delete stub;
	return 0;
}
Beispiel #9
0
int Configuration::load(int argc, char const** argv) {
	int ret = Status::STAT_OK;

	// Figure out who we are
	fs::path bin = argv[0];
	_bin_name = new ReferencedString(bin.filename().native());

	// parse arguments

	for (int i = 1; i < argc; i++) {
		ret = parseOption(argv[i], NULL);

		if (ret == Status::STAT_NEXT_ARG) {
			if (i < argc-1 && argv[i+1][0] != '-') {
				ret = parseOption(argv[i], argv[i+1]);
				i++;
			} else {
				std::cerr << "ERROR: Expected an option following \"" << argv[i] << "\"." << std::endl;
				return Status::STAT_BAD_ARG;
			}
		}

		switch (ret) {
		case Status::STAT_BAD_ARG:
			std::cerr << "ERROR: Unrecognized option: \"" << argv[i] << "\"." << std::endl;
			/* no break */
		case Status::STAT_HELP:
		case Status::STAT_VERSION:
			return ret;
		default:
			continue;
		};

	}
	return ret;
}
Beispiel #10
0
int CConversionOptions::parseCommandLine(int argc, char **argv)
{
	if(argc<2){
		MUSEERROR(err_NoInputFile,0,0)
	}

	//Last option is sourcefile!
	sourceFile=argv[argc-1];

	//parse the other options
	for(int i=1;i<argc-1;i++){
		parseOption(argv[i]);	
	}
	return 0;
}
Beispiel #11
0
/**
 * Call the parseOption function, but before, intercept local parameters (--help and --usage).
 * @param key Define the key of arguement (the short name, eg. -v)
 * @param arg Define the given arguement in string format (-a or --all). For default value,
 *            it will be equal to value.
 * @param value Define the value given with the arguement if available.
 * @throw svutExArgpError Exception used to notify arguement error.
**/
void svutArgp::callParseOption ( char key, std::string arg, std::string value )  throw (svutExArgpError)
{
	switch (key)
	{
		case '?':
			this->showHelp();
			exit(0);
			break;
		case SVUT_USAGE_KEY:
			this->showUsage();
			exit(0);
			break;
		default:
			parseOption(key,arg,value);
	}
}
Beispiel #12
0
//------------------------------------------------------------------------------
int LArguments::parseInternalOption(LString option) {
    int ret;
    if(option == "--version" || option == "-v") {
        printVersion();
        return L_EXIT;
        }
    if(option == "--help" || option == "-h") {
        printUsage();
        return L_EXIT;
        }
    ret = parseOption(option);
    if(ret < 0) {
        llog.log(LLog::error, LString("Unknown option ") + option);
        }
    return ret;
    }
Beispiel #13
0
void parseOptions(
		std::vector<Option>& options,
		const std::string& fileName,
		const std::string& fileModes,
		const std::string& accessModes,
		std::set<std::string>* optionsSet,
		CLogSubsystem* logSubsystem) {

	if (!logSubsystem) {
		assert(logSubsystem);
	}

	LuaParser luaParser(fileName, fileModes, accessModes);

	if (!luaParser.Execute()) {
		throw content_error("luaParser.Execute() failed: "
				+ luaParser.GetErrorLog());
	}

	const LuaTable root = luaParser.GetRoot();
	if (!root.IsValid()) {
		throw content_error("root table invalid");
	}

	std::set<std::string>* myOptionsSet = NULL;
	if (optionsSet == NULL) {
		myOptionsSet = new std::set<std::string>();
	} else {
		myOptionsSet = optionsSet;
	}
	for (int index = 1; root.KeyExists(index); index++) {
		Option opt;
		try {
			parseOption(root, index, opt, *myOptionsSet);
			options.push_back(opt);
		} catch (content_error& err) {
			logOutput.Print(*logSubsystem,
					"Failed parsing option %d from %s: %s",
					index, fileName.c_str(), err.what());
		}
	}
	if (optionsSet == NULL) {
		delete myOptionsSet;
		myOptionsSet = NULL;
	}
}
int main(int argc, char** argv) {
  if(parseOption(argc, argv)) {
    return 1;
  }

  BCCScriptRef script;

  if((script = loadScript()) == NULL) {
    return 2;
  }

  if(RunRoot && runRoot(script)) {
    return 6;
  }

  bccDisposeScript(script);

  return 0;
}
Beispiel #15
0
void Kernel::doSwitches(int argc, const char *argv[], ProgramArgs& args)
{
    StringList stringArgs;
    OptionsMap& stageOptions = m_manager.stageOptions();

    // Scan the argument vector for extra stage options.  Pull them out and
    // stick them in the list.  Let the ProgramArgs handle everything else.
    // NOTE: This depends on the format being "option=value" rather than
    //   "option value".  This is what we've always expected, so no problem,
    //   but it would be better to be more flexible.
    for (int i = 0; i < argc; ++i)
    {
        std::string stageName, opName, value;

        if (parseOption(argv[i], stageName, opName, value))
        {
            Option op(opName, value);
            stageOptions[stageName].add(op);
        }
        else
            stringArgs.push_back(argv[i]);
    }

    try
    {
        addBasicSwitches(args);

        // parseSimple allows us to scan for the help option without
        // raising exception about missing arguments and so on.
        args.parseSimple(stringArgs);
        addSwitches(args);
        if (!m_showHelp)
        {
            args.reset();
            args.parse(stringArgs);
        }
    }
    catch (arg_error& e)
    {
        throw pdal_error(e.m_error);
    }
}
Beispiel #16
0
bool CupsdConf::loadFromFile(const QString &filename)
{
    QFile f(filename);
    if(!f.exists() || !f.open(IO_ReadOnly))
        return false;
    else
    {
        QTextStream t(&f);
        QString line;
        bool done(false), value(true);
        while(!done && value)
        {
            line = t.readLine().simplifyWhiteSpace();
            if(line.isEmpty())
            {
                if(t.atEnd())
                    done = true;
                else
                    continue;
            }
            else if(line[0] == '#')
                continue;
            else if(line.left(9).lower() == "<location")
            {
                CupsLocation *location = new CupsLocation();
                locations_.append(location);
                if(!location->parseResource(line) || !parseLocation(location, t))
                    value = false;
                // search corresponding resource
                for(resources_.first(); resources_.current(); resources_.next())
                    if(resources_.current()->path_ == location->resourcename_)
                        location->resource_ = resources_.current();
            }
            else
                value = parseOption(line);
        }
        f.close();
        return value;
    }
}
Beispiel #17
0
int main(int argc, char** argv)
{
	/* Parse options */
	parseOption(argc, argv);
	/* Print to file */
	printf("output : %s\n", filename);
	printf("count  : %d\n", count);
	printf("xmin   : %lf\n", xmin);
	printf("ymin   : %lf\n", ymin);
	printf("zmin   : %lf\n", zmin);
	printf("mmin   : %lf\n", mmin);
	printf("xmax   : %lf\n", xmax);
	printf("ymax   : %lf\n", ymax);
	printf("zmax   : %lf\n", zmax);
	printf("mmax   : %lf\n", mmax);

	//random1();
	//sphere();
	sphere2();

	return(EXIT_SUCCESS);
}
Beispiel #18
0
Config::Config()
{
	mShellCommand = 0;
	mConfigBuf = 0;
	mConfigEntrys = 0;

	const s8 *home = getenv("HOME");
	if (!home) {
		if (getuid()) return;
		home = "/root";
	}

	s8 name[64];
	snprintf(name, sizeof(name), "%s/%s", home, ".fbtermrc");

	checkConfigFile(name);

	struct stat cstat;
	if (stat(name, &cstat) == -1) return;
	if (cstat.st_size > MAX_CONFIG_FILE_SIZE) return;

	s32 fd = open(name, O_RDONLY);
	if (fd == -1) return;

	mConfigBuf = new char[cstat.st_size + 1];
	mConfigBuf[cstat.st_size] = 0;

	s32 ret = read(fd, mConfigBuf, cstat.st_size);
	close(fd);

	s8 *end, *start = mConfigBuf;
	do {
		end = strchr(start, '\n');
		if (end) *end = 0;
		parseOption(start);
		if (end) start = end + 1;
	} while (end && *start);
}
void CommandLineArgumentsParser::parseArguments(int argc, char** argv) throw (std::invalid_argument){

	if( !isArgumentEnough(argc) ) {
		throw std::invalid_argument("It is necessary to contain Class name.");
	}
	if( isContainLanguageSettingMultiple(argc, argv) ) {
		throw std::invalid_argument("Language Setting is contained once in arguments.");
	}
	if( isThereUnkownOption(argc, argv) ) {
		throw std::invalid_argument("Unknown Options are there.");
	}

	for(int i = 1; i < argc; ++i) {
		std::string argument(argv[i]);
		if( isOption(argument) ){
			parseOption(argument);
		}
		else {
			className_.push_back(argv[i]);
		}
	}

//	return className_;
}
Beispiel #20
0
void UciEngine::parseLine(const QString& line)
{
	const QStringRef command(firstToken(line));

	if (command == "info")
	{
		parseInfo(command);
	}
	else if (command == "bestmove")
	{
		if (state() != Thinking)
		{
			if (state() == FinishingGame)
				pong();
			else
				qDebug() << "Unexpected move from" << name();
			return;
		}

		QString moveString(nextToken(command).toString());
		m_moveStrings += " " + moveString;
		Chess::Move move = board()->moveFromString(moveString);

		if (!move.isNull())
			emitMove(move);
		else
			forfeit(Chess::Result::IllegalMove, moveString);
	}
	else if (command == "readyok")
	{
		pong();
	}
	else if (command == "uciok")
	{
		if (state() == Starting)
		{
			onProtocolStart();
			ping();
		}
	}
	else if (command == "id")
	{
		QStringRef tag(nextToken(command));
		if (tag == "name" && name() == "UciEngine")
			setName(nextToken(tag, true).toString());
	}
	else if (command == "registration")
	{
		if (nextToken(command) == "error")
		{
			qDebug("Failed to register UCI engine %s", qPrintable(name()));
			write("register later");
		}
	}
	else if (command == "option")
	{
		EngineOption* option = parseOption(command);
		QString variant;

		if (option == 0 || !option->isValid())
			qDebug("Invalid UCI option from %s: %s",
				qPrintable(name()), qPrintable(line));
		else if (!(variant = variantFromUci(option->name())).isEmpty())
			addVariant(variant);
		else if (option->name() == "UCI_Opponent")
			m_sendOpponentsName = true;
		else if (option->name() == "Ponder"
		     ||  (option->name().startsWith("UCI_") &&
			  option->name() != "UCI_LimitStrength" &&
			  option->name() != "UCI_Elo"))
		{
			// TODO: Deal with UCI features
		}
		else
		{
			addOption(option);
			return;
		}

		delete option;
	}
}
Beispiel #21
0
int parseCmdArgs(genRandPropsPtr props, int argv, char** argc) {
    
    int arg = 0;
    int argLen = 0;
    char** option;
    
    //Parse the argument list if there are more
    // arguments than just the executable string.
    for(arg = 1; arg <= argv-1; arg++) {
    
        //Check if we are just printing help or
        // version information.
        if(arg == 1) {
        
            //If it is either a request for the help
            // or version number, print that and exit.
            if(strstr(argc[arg], "-h") != NULL) {
                printDirections(); return 1;
            }
            else if(strstr(argc[arg], "-v") != NULL) {
                printVersion(); return 2;
            }
            //Otherwise try to parse the first argument
            // as an option.
            else {
                option = parseOption(argc, &arg);
            }
        }
        //If more than one argument and we have moved
        // past the first, parse it.
        else
            option = parseOption(argc, &arg);
        
        //If an argument was not formatted correctly,
        // skip to the next argument.
        if(option == NULL) {
            printf("Ignoring %s, improper argument format.\n", argc[arg++]);
            continue;
        }
            
        //Record the program parameter.
        switch(option[0][0]) {
        
            case 'f':
                argLen = strlen(option[1]);
                props->fileName = (char *)realloc(props->fileName, sizeof(char)*argLen);
                strcpy(props->fileName, option[1]);
                break;
            
            case 'n':
                if(atoi(option[1]) == 0)
                    printf("Invalid number format - Using default argument\n");
                else
                    props->elements = atoi(option[1]);
                break;
            
            case 'd':
                props->delimiter = option[1][0];
                break;
                
            case 's':
                if(atoi(option[1]) != 0) {
                    props->seedValue = atoi(option[1]);
                    props->seedType = 'm';
                }
                break;
                
            case 'r':
                if(atoi(option[1]) != 0) {
                    int newSeedRefreshInterval = atoi(option[1]);
                    if(newSeedRefreshInterval < props->elements)
                        props->randGenPeriod = newSeedRefreshInterval;
                    else
                        printf("Keeping default reinitialization period, invalid argument.\n");
                }
                else
                    printf("Invalid number.\n");
                break;
                
            case 'l':
                if(atoi(option[1]) != 0) {
                    int newLowerBound = atoi(option[1]);
                    if(newLowerBound >= 0)
                        props->randLowerBound = newLowerBound;
                    else
                        printf("Keeping default lower bound, invalid argument.\n");
                }
                else
                    printf("Invalid number.\n");
                break;
                
            case 'h':
                if(atoi(option[1]) != 0) {
                    int newUpperBound = atoi(option[1]);
                    if(newUpperBound <= RAND_MAX)
                        props->randUpperBound = newUpperBound;
                    else
                        printf("Keeping default upper bound, invalid argument.\n");
                }
                else
                    printf("Invalid number.\n");
                break;
                
            case 'b':
                if(strcmp(option[1], "true") == 0) {
                    props->fileMode = (char *)realloc(props->fileMode, sizeof(char)*2);
                    strcpy(props->fileMode, "wb");
                    printf("Will now write file in binary instead of text.\n");
                }
                else
                    printf("Writing text instead of binary\n");
                break;
                
            //If we don't know the option, report.
            default:
                printf("Invalid option: %c.\n", option[0][0]);
        }
        
        //Clean up.
        free(option[0]);
        free(option[1]);
        free(option);
    }
    
    return 0;
}
Beispiel #22
0
int main(int argc, char **argv)
{
	Args args = parseOption(argc, argv);

	if (!args.forever && args.recsec <= 0) {
		std::cerr << "recsec must be (recsec > 0)." << std::endl;
		exit(1);
	}
	// ログ出力先設定
	std::ostream& log = args.stdout ? std::cerr : std::cout;
	log << "recfsusb2n ver. 0.9.2" << std::endl << "ISDB-T DTV Tuner FSUSB2N" << std::endl;
	EM2874Device::setLog(&log);

	EM2874Device *usbDev = EM2874Device::AllocDevice();
	if(usbDev == NULL)
		return 1;
	usbDev->initDevice2();

	KtvDevice *pDev;
	if(usbDev->getDeviceID() == 2) {
		pDev = new Ktv2Device(usbDev);
	}else{
		pDev = new Ktv1Device(usbDev);
	}

	pDev->InitTuner();
	// 周波数を計算 (UHF13ch = 473143 kHz)
	pDev->SetFrequency( (args.channel * 6000) + 395143 );
	pDev->InitDeMod();
	pDev->ResetDeMod();

#ifdef B25
	// B25初期化
	B25Decoder b25dec;
	if (args.b25) {
		b25dec.setRound(4);
		b25dec.setStrip(true);
		b25dec.setEmmProcess(false);
		if(b25dec.open(usbDev) == 0) {
			log << "B25Decoder initialized." << std::endl;
		}else{
			// エラー時b25を行わず処理続行。終了ステータス1
			std::cerr << "disable b25 decoding." << std::endl;
			args.b25 = false;
		}
	}
#endif /* defined(B25) */

	// 出力先ファイルオープン
	FILE *dest;
	if(!args.stdout) {
		dest = fopen(args.destfile, "w");
		if (NULL == dest) {
			std::cerr << "can't open file '" << args.destfile << "' to write." << std::endl;
			exit(1);
		}
	}else dest = stdout;

	// SIGINT, SIGTERM
	struct sigaction sa;
	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_handler = sighandler;
	sa.sa_flags = SA_RESTART;
	sigaction(SIGINT,  &sa, NULL);
	sigaction(SIGTERM, &sa, NULL);

	do {
		sleep(1);
	} while(pDev->DeMod_GetSequenceState() < 8 && !caughtSignal);

	// 録画時間の基準開始時間
	time_t time_start = time(NULL);

	usbDev->startStream();

	// Main loop
	while (!caughtSignal && (args.forever || time(NULL) <= time_start + args.recsec)) {
		usleep(750000);
		const void *buf = NULL;
		int rlen = usbDev->getStream(&buf);
		if (0 == rlen) continue;
#ifdef B25
			// B25を経由して受け取る
			if (args.b25) {
				const uint8_t *b25buf = (const uint8_t *)buf;
				b25dec.put(b25buf, rlen);
				rlen = b25dec.get(&b25buf);
				if (0 == rlen) {
					continue;
				}
				buf = b25buf;
			}
#endif /* defined(B25) */

		if(args.verbose) {
			log << "Sequence = " << (unsigned)pDev->DeMod_GetSequenceState() << ", Quality = " << 0.02*pDev->DeMod_GetQuality()
 << ", " << rlen << "bytes wrote." << std::endl;
		}
		if((unsigned)rlen > fwrite(buf, 1, rlen, dest)) {
			log << "fwrite failed." << std::endl;
		}
	}

	if (caughtSignal) {
		log << "interrupted." << std::endl;
	}
	usbDev->stopStream();

	// Default Signal Handler
	struct sigaction saDefault;
	memset(&saDefault, 0, sizeof(struct sigaction));
	saDefault.sa_handler = SIG_DFL;
	sigaction(SIGINT,  &saDefault, NULL);
	sigaction(SIGTERM, &saDefault, NULL);

#ifdef B25
	// B25Decoder flush Data
	if (args.b25) {
		b25dec.flush();
		const uint8_t *buf = NULL;
		int rlen = b25dec.get(&buf);
		if (0 < rlen) {
			fwrite(buf, 1, rlen, dest);
		}
	}
#endif /* defined(B25) */

	// 録画時間の測定
	time_t time_end = time(NULL);

	fflush(dest);
	if(!args.stdout) {
		fclose(dest);
	}

	log << "done." << std::endl;
	log << "Rec time: " << static_cast<unsigned>(time_end - time_start) << " sec." << std::endl;
	delete pDev;
	delete usbDev;
	return 0;
}
Beispiel #23
0
// main logic of the component - a slot triggered upon data entering the socket
// comments inline...
void QwwSmtpClientPrivate::_q_readFromSocket() {
    while (socket->canReadLine()) {
        QString line = socket->readLine();
        qDebug() << "SMTP <<<" << line.toUtf8().constData();
        QRegExp rx("(\\d+)-(.*)\n");        // multiline response (aka 250-XYZ)
        QRegExp rxlast("(\\d+) (.*)\n");    // single or last line response (aka 250 XYZ)
        bool mid = rx.exactMatch(line);
        bool last = rxlast.exactMatch(line);
        // multiline
        if (mid){
            int status = rx.cap(1).toInt();
            SMTPCommand &cmd = commandqueue.head();
            switch (cmd.type) {
            // trying to connect
            case SMTPCommand::Connect: {
                    int stage = cmd.extra.toInt();
                    // stage 0 completed with success - socket is connected and EHLO was sent
                    if(stage==1 && status==250){
                        QString arg = rx.cap(2).trimmed();
                        parseOption(arg);   // we're probably receiving options
                    }
                }
                break;
            // trying to establish deferred SSL handshake
            case SMTPCommand::StartTLS: {
                    int stage = cmd.extra.toInt();
                    // stage 0 (negotiation) completed ok
                    if(stage==1 && status==250){
                        QString arg = rx.cap(2).trimmed();
                        parseOption(arg);   // we're probably receiving options
                    }
                }
                default: break;
            }
        } else
        // single line
        if (last) {
            int status = rxlast.cap(1).toInt();
            SMTPCommand &cmd = commandqueue.head();
            switch (cmd.type) {
            // trying to connect
            case SMTPCommand::Connect: {
                int stage = cmd.extra.toInt();
                // connection established, server sent its banner
                if (stage==0 && status==220) {
                    sendEhlo(); // connect ok, send ehlo
                }
                // server responded to EHLO
                if (stage==1 && status==250){
                    // success (EHLO)
                    parseOption(rxlast.cap(2).trimmed()); // we're probably receiving the last option
                    errorString.clear();
                    setState(QwwSmtpClient::Connected);
                    processNextCommand();
                }
                // server responded to HELO (EHLO failed)
                if (state==2 && status==250) {
                    // success (HELO)
                    errorString.clear();
                    setState(QwwSmtpClient::Connected);
                    processNextCommand();
                }
                // EHLO failed, reason given in errorString
                if (stage==1 && (status==554 || status==501 || status==502 || status==421)) {
                    errorString = rxlast.cap(2).trimmed();
                    sendHelo(); // ehlo failed, send helo
                    cmd.extra = 2;
                }
                //abortDialog();
            }
            break;
            // trying to establish a delayed SSL handshake
            case SMTPCommand::StartTLS: {
                int stage = cmd.extra.toInt();
                // received an invitation from the server to enter TLS mode
                if (stage==0 && status==220) {
                    qDebug() << "SMTP ** startClientEncruption";
                    socket->startClientEncryption();
                }
                // TLS established, connection is encrypted, EHLO was sent
                else if (stage==1 && status==250) {
                    setState(QwwSmtpClient::Connected);
                    parseOption(rxlast.cap(2).trimmed());   // we're probably receiving options
                    errorString.clear();
                    emit q->tlsStarted();
                    processNextCommand();
                }
                // starttls failed
                else {
                    qDebug() << "TLS failed at stage " << stage << ": " << line;
                    errorString = "TLS failed";
                    emit q->done(false);
                }
            }
            break;
            // trying to authenticate the client to the server
            case SMTPCommand::Authenticate: {
                int stage = cmd.extra.toInt();
                if (stage==0 && status==334) {
                    // AUTH mode was accepted by the server, 1st challenge sent
                    QwwSmtpClient::AuthMode authmode = (QwwSmtpClient::AuthMode)cmd.data.toList().at(0).toInt();
                    errorString.clear();
                    switch (authmode) {
                    case QwwSmtpClient::AuthPlain:
                        sendAuthPlain(cmd.data.toList().at(1).toString(), cmd.data.toList().at(2).toString());
                        break;
                    case QwwSmtpClient::AuthLogin:
                        sendAuthLogin(cmd.data.toList().at(1).toString(), cmd.data.toList().at(2).toString(), 1);
                        break;
                    default:
                        qWarning("I shouldn't be here");
                        setState(QwwSmtpClient::Connected);
                        processNextCommand();
                        break;
                    }
                    cmd.extra = stage+1;
                } else if (stage==1 && status==334) {
                    // AUTH mode and user names were acccepted by the server, 2nd challenge sent
                    QwwSmtpClient::AuthMode authmode = (QwwSmtpClient::AuthMode)cmd.data.toList().at(0).toInt();
                    errorString.clear();
                    switch (authmode) {
                    case QwwSmtpClient::AuthPlain:
                        // auth failed
                        setState(QwwSmtpClient::Connected);
                        processNextCommand();
                        break;
                    case QwwSmtpClient::AuthLogin:
                        sendAuthLogin(cmd.data.toList().at(1).toString(), cmd.data.toList().at(2).toString(), 2);
                        break;
                    default:
                        qWarning("I shouldn't be here");
                        setState(QwwSmtpClient::Connected);
                        processNextCommand();
                        break;
                    }
                } else if (stage==2 && status==334) {
                    // auth failed
                    errorString = rxlast.cap(2).trimmed();
                    setState(QwwSmtpClient::Connected);
                    processNextCommand();
                } else if (status==235) {
                    // auth ok
                    errorString.clear();
                    emit q->authenticated();
                    setState(QwwSmtpClient::Connected);
                    processNextCommand();
                } else {
                    errorString = rxlast.cap(2).trimmed();
                    setState(QwwSmtpClient::Connected);
                    emit q->done(false);
                }
            }
            break;
            // trying to send mail
            case SMTPCommand::Mail:
            case SMTPCommand::MailBurl:
            {
                int stage = cmd.extra.toInt();
                // temporary failure upon receiving the sender address (greylisting probably)
                if (status==421 && stage==0) {
                    errorString = rxlast.cap(2).trimmed();
                    // temporary envelope failure (greylisting)
                    setState(QwwSmtpClient::Connected);
                    processNextCommand(false);
                }
                if (status==250 && stage==0) {
                    // sender accepted
                    errorString.clear();
                    sendRcpt();
                } else if (status==250 && stage==1) {
                    // all receivers accepted
                    if (cmd.type == SMTPCommand::MailBurl) {
                        errorString.clear();
                        QByteArray url = cmd.data.toList().at(2).toByteArray();
                        qDebug() << "SMTP >>> BURL" << url << "LAST";
                        socket->write("BURL " + url + " LAST\r\n");
                        cmd.extra=2;
                    } else {
                        errorString.clear();
                        qDebug() << "SMTP >>> DATA";
                        socket->write("DATA\r\n");
                        cmd.extra=2;
                    }
                } else if ((cmd.type == SMTPCommand::Mail && status==354 && stage==2)) {
                    // DATA command accepted
                    errorString.clear();
                    QByteArray toBeWritten = cmd.data.toList().at(2).toString().toUtf8();
                    qDebug() << "SMTP >>>" << toBeWritten << "\r\n.\r\n";
                    socket->write(toBeWritten); // expecting data to be already escaped (CRLF.CRLF)
                    socket->write("\r\n.\r\n"); // termination token - CRLF.CRLF
                    cmd.extra=3;
                } else if ((cmd.type == SMTPCommand::MailBurl && status==354 && stage==2)) {
                    // BURL succeeded
                    setState(QwwSmtpClient::Connected);
                    errorString.clear();
                    processNextCommand();
                } else if ((cmd.type == SMTPCommand::Mail && status==250 && stage==3)) {
                    // mail queued
                    setState(QwwSmtpClient::Connected);
                    errorString.clear();
                    processNextCommand();
                } else {
                    // something went wrong
                    errorString = rxlast.cap(2).trimmed();
                    setState(QwwSmtpClient::Connected);
                    emit q->done(false);
                    processNextCommand();
                }
            }
                default: break;
            }
        } else {
            qDebug() << "None of two regular expressions matched the input" << line;
        }
    }
}
int main(int argc, char** argv) {
  if(!parseOption(argc, argv)) {
    fprintf(stderr, "failed to parse option\n");
    return 1;
  }

  const char *bitcode = NULL;
  size_t bitcodeSize = readBitcode(&bitcode);

  unsigned int version = 0;

  bcinfo::BitcodeWrapper bcWrapper((const char *)bitcode, bitcodeSize);
  if (bcWrapper.getBCFileType() == bcinfo::BC_WRAPPER) {
    version = bcWrapper.getTargetAPI();
    if (verbose) {
      printf("Found bitcodeWrapper\n");
    }
  } else if (translateFlag) {
    version = 12;
  }

  if (verbose) {
    printf("targetAPI: %u\n", version);
    printf("compilerVersion: %u\n", bcWrapper.getCompilerVersion());
    printf("optimizationLevel: %u\n\n", bcWrapper.getOptimizationLevel());
  }

  llvm::OwningPtr<bcinfo::BitcodeTranslator> BT;
  BT.reset(new bcinfo::BitcodeTranslator(bitcode, bitcodeSize, version));
  if (!BT->translate()) {
    fprintf(stderr, "failed to translate bitcode\n");
    return 3;
  }

  llvm::OwningPtr<bcinfo::MetadataExtractor> ME;
  ME.reset(new bcinfo::MetadataExtractor(BT->getTranslatedBitcode(),
                                         BT->getTranslatedBitcodeSize()));
  if (!ME->extract()) {
    fprintf(stderr, "failed to get metadata\n");
    return 4;
  }

  if (verbose) {
    dumpMetadata(ME.get());

    const char *translatedBitcode = BT->getTranslatedBitcode();
    size_t translatedBitcodeSize = BT->getTranslatedBitcodeSize();

    llvm::LLVMContext &ctx = llvm::getGlobalContext();
    llvm::llvm_shutdown_obj called_on_exit;

    llvm::OwningPtr<llvm::MemoryBuffer> mem;

    mem.reset(llvm::MemoryBuffer::getMemBuffer(
        llvm::StringRef(translatedBitcode, translatedBitcodeSize),
        inFile.c_str(), false));

    llvm::OwningPtr<llvm::Module> module;
    std::string errmsg;
    module.reset(llvm::ParseBitcodeFile(mem.get(), ctx, &errmsg));
    if (module.get() != 0 && module->MaterializeAllPermanently(&errmsg)) {
      module.reset();
    }

    if (module.get() == 0) {
      if (errmsg.size()) {
        fprintf(stderr, "error: %s\n", errmsg.c_str());
      } else {
        fprintf(stderr, "error: failed to parse bitcode file\n");
      }
      return 5;
    }

    llvm::OwningPtr<llvm::tool_output_file> tof(
        new llvm::tool_output_file(outFile.c_str(), errmsg,
                                   llvm::sys::fs::F_Binary));
    llvm::OwningPtr<llvm::AssemblyAnnotationWriter> ann;
    module->print(tof->os(), ann.get());

    tof->keep();
  }

  if (infoFlag) {
    if (dumpInfo(ME.get()) != 0) {
      fprintf(stderr, "Error dumping info file\n");
      return 6;
    }
  }

  releaseBitcode(&bitcode);

  return 0;
}
Beispiel #25
0
bool parseCommandline(const std::vector<Common::UString> &argv, Common::UString &target, int &code) {
	target.clear();

	Common::UString key;

	bool stopMark = false;
	for (size_t i = 1; i < argv.size(); i++) {

		if (!key.empty()) {
		// Still got one parameter missing from last time
			if (!setOption(key, argv[i])) {
				code = 1;
				return false;
			}

			continue;
		}

		if (!stopMark && argv[i].beginsWith("-")) {
			if (argv[i] == "--") {
				stopMark = true;
				continue;
			}

			if (argv[i] == "--help") {
				code = 0;
				displayUsage(argv[0]);
				return false;
			}

			if (argv[i] == "--version") {
				code = 0;
				displayVersion();
				return false;
			}

			if (!parseOption(argv[i], key)) {
				code = 1;
				return false;
			}

			if (key == "listdebug") {
				setOption(key, "true");
				key.clear();
			}

			if (key == "listlangs") {
				setOption(key, "true");
				key.clear();
			}

			continue;
		}

		if (!target.empty()) {
			warning("Found multiple target (\"%s\" and \"%s\")", target.c_str(), argv[i].c_str());
			code = 1;
			return false;
		}

		target = argv[i];
	}

	if (target.empty() && !ConfigMan.hasKey("path") && !ConfigMan.getBool("listdebug", false)) {
		displayUsage(argv[0]);
		code = 1;
		return false;
	}

	return true;
}
Beispiel #26
0
/** main */
int
main(int argc, char *argv[])
{
	Args args = parseOption(argc, argv);
	// 正常終了時戻り値
	int result = 0;
	boost::scoped_ptr<Recordable> tuner(NULL);
	timeval tv_start;
#ifdef UDP
	Udp udp;
#endif /* defined(UDP) */
#ifdef HTTP
	int dest = 1; // stdout
	int connected_socket = 0;
	int listening_socket = 0;
#endif /* defined(HTTP) */
	
	// 引数確認
	if (!args.forever && args.recsec <= 0) {
		std::cerr << "recsec must be (recsec > 0)." << std::endl;
		exit(1);
	}
	
	// 録画時間の基準開始時間
	time_t time_start = time(NULL);
	
	// ログ出力先設定
	std::ostream& log = args.stdout ? std::cerr : std::cout;

#ifdef HTTP
	if( !args.http_mode ){
		// 出力先ファイルオープン
		if(!args.stdout) {
			dest = open(args.destfile, (O_RDWR | O_CREAT | O_TRUNC), 0666);
			if (0 > dest) {
				std::cerr << "can't open file '" << args.destfile << "' to write." << std::endl;
				exit(1);
			}
		}
	}else{
		struct sockaddr_in	sin;
		int					sock_optval = 1;
		int					ret;

		fprintf(stderr, "run as a daemon..\n");
		if(daemon(1,1)){
			perror("failed to start");
			exit(1);
		}

		listening_socket = socket(AF_INET, SOCK_STREAM, 0);
		if ( listening_socket == -1 ){
			perror("socket");
			exit(1);
		}

		if ( setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR, &sock_optval, sizeof(sock_optval)) == -1 ){
			perror("setsockopt");
			exit(1);
		}

		sin.sin_family = AF_INET;
		sin.sin_port = htons(args.http_port);
		sin.sin_addr.s_addr = htonl(INADDR_ANY);

		if ( bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0 ){
			perror("bind");
			exit(1);
		}

		ret = listen(listening_socket, SOMAXCONN);
		if ( ret == -1 ){
			perror("listen");
			exit(1);
		}
		fprintf(stderr,"listening at port %d\n", args.http_port);
	}

	while(1){
		if ( args.http_mode ) {
			struct sockaddr_in	peer_sin;
			int					read_size;
			unsigned int		len;
			char				buffer[256];
			char				s0[256],s1[256],s2[256];
			char				delim[] = "/";
			char				*channel;
			char				*sidflg;

			len = sizeof(peer_sin);
			connected_socket = accept(listening_socket, (struct sockaddr *)&peer_sin, &len);
			if ( connected_socket == -1 ) {
				perror("accept");
				exit(1);
			}

			int error;
			char hbuf[NI_MAXHOST], nhbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
			error = getnameinfo((struct sockaddr *)&peer_sin, sizeof(peer_sin), hbuf, sizeof(hbuf), NULL, 0, 0);
			if (error) {
				fprintf(stderr, "getnameinfo(): %s\n", gai_strerror(error));
				exit(1);
			}
			error = getnameinfo((struct sockaddr *)&peer_sin, sizeof(peer_sin), nhbuf, sizeof(nhbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV);
			if (error) {
				fprintf(stderr, "getnameinfo(): %s\n", gai_strerror(error));
				exit(1);
			}
			fprintf(stderr,"connect from: %s [%s] port %s\n", hbuf, nhbuf, sbuf);

			read_size = read_line(connected_socket, buffer);
			fprintf(stderr, "request command is %s\n", buffer);
			// ex:GET /C8/333 HTTP/1.1
			sscanf(buffer, "%s%s%s", s0, s1, s2);
			channel = strtok(s1, delim);
			if (channel != NULL) {
				fprintf(stderr, "Channel: %s\n", channel);
				parseChannel(&args, channel);
				sidflg = strtok(NULL, delim);
				if (sidflg != NULL) {
					fprintf(stderr, "SID: %s\n", sidflg);
#ifdef TSSL
					args.splitter = true;
					args.sid_list = sidflg;
				} else {
					args.splitter = false;
					args.sid_list = NULL;
#endif /* defined(TSSL) */
				}
			}
			char header[] =  "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nCache-Control: no-cache\r\n\r\n";
			write(connected_socket, header, strlen(header));
			//set write target to http
			dest = connected_socket;
		}
#endif /* defined(HTTP) */

#ifdef B25
	// B25初期化
	B25Decoder b25dec;
	if (args.b25) {
		try {
			b25dec.setRound(args.round);
			b25dec.setStrip(args.strip);
			b25dec.setEmmProcess(args.emm);
			b25dec.open();
			log << "B25Decoder initialized." << std::endl;
		} catch (b25_error& e) {
			std::cerr << e.what() << std::endl;
			
#ifdef HTTP
			if (!args.http_mode) {
#endif /* defined(HTTP) */
			// エラー時b25を行わず処理続行。終了ステータス1
			std::cerr << "disable b25 decoding." << std::endl;
			args.b25 = false;
			result = 1;
#ifdef HTTP
			}
#endif /* defined(HTTP) */
		}
	}
#endif /* defined(B25) */

#ifdef UDP
	// UDP初期化
	if( ! args.ip.empty() ){
		try{
			udp.setLog(&log);
			udp.init( args.ip, args.port );
		}
		catch( const char* e ){
			log << e << std::endl;
			log << "disable UDP." << std::endl;
		}
	}
#endif /* defined(UDP) */

#ifdef TSSL
	/* initialize splitter */
	splitbuf_t splitbuf;
	splitbuf.size = 0;
	splitter *splitter = NULL;
	int split_select_finish = TSS_ERROR;
	int code;
	if(args.splitter) {
		splitter = split_startup(args.sid_list);
		if(splitter->sid_list == NULL) {
			fprintf(stderr, "Cannot start TS splitter\n");
			return 1;
		}
	}
#endif /* defined(TSSL) */

	// Tuner取得
	tuner.reset(createRecordable(args.type));
#ifdef HDUS
	if( args.type == TUNER_HDUS ) log << "Tuner type is HDUS." << std::endl;
	else if( args.type == TUNER_HDP ) log << "Tuner type is HDP." << std::endl;
#endif /* defined(HDUS) */
	// ログ出力先設定
	tuner->setLog(&log);
	// ロックファイル設定
	if (args.lockfile != NULL) {
		tuner->setDetectLockFile(args.lockfile);
	}
	
	// Tuner初期化
	int retryCount = ERROR_RETRY_MAX;
	while (0 < retryCount) {
		try {
			// チューナopen
			bool r = tuner->open(args.lnb);
			if (!r) {
				std::cerr << "can't open tuner." << std::endl;
				exit(1);
			}
			
			// チャンネル設定
			tuner->setChannel(args.band, args.channel);
			
			// 開始時SignalLevel出力
			float lev_before = 0.0;
			int lev_retry_count = SIGNALLEVEL_RETRY_MAX;
			while (lev_before < SIGNALLEVEL_RETRY_THRESHOLD && 0 < lev_retry_count) {
				lev_before = tuner->getSignalLevel();
				log << "Signal level: " << lev_before << std::endl;
				
				lev_retry_count--;
				usleep(SIGNALLEVEL_RETRY_INTERVAL * 1000);
			}
		} catch (usb_error& e) {
			// リトライ処理
			retryCount--;
			std::cerr << e.what();
			if (retryCount <= 0) {
				std::cerr << " abort." << std::endl;
				exit(1);
			}
			std::cerr << " retry." << std::endl;
			
			tuner->close();
			usleep(ERROR_RETRY_INTERVAL * 1000);
			continue;
		}
		break;
	}
	
#ifndef HTTP
	// 出力先ファイルオープン
	FILE *dest = stdout;
	if (!args.stdout) {
		dest = fopen(args.destfile, "w");
		if (NULL == dest) {
			std::cerr << "can't open file '" << args.destfile << "' to write." << std::endl;
			exit(1);
		}
	}
#endif /* !defined(HTTP) */
	
	// 出力開始/時間計測
	log << "Output ts file." << std::endl;
	if (gettimeofday(&tv_start, NULL) < 0) {
		std::cerr << "gettimeofday failed." << std::endl;
		exit(1);
	}
	
	// SIGINT/SIGTERMキャッチ
	struct sigaction sa;
	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_handler = sighandler;
	sa.sa_flags = SA_RESTART;
	struct sigaction saDefault;
	memset(&saDefault, 0, sizeof(struct sigaction));
	saDefault.sa_handler = SIG_DFL;
	sigaction(SIGINT,  &sa, NULL);
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGPIPE, &sa, NULL);
	
	uint8_t		*buf = NULL;
	int			rlen;
	
	// 受信スレッド起動
	tuner->startStream();
	// データ読み出し
	uint32_t urb_error_cnt = 0;
	while (!caughtSignal && (args.forever || time(NULL) <= time_start + args.recsec)) {
		try {
			rlen = tuner->getStream((const uint8_t **)&buf, 200);
			if (0 == rlen) {
				continue;
			}
			
#ifdef B25
			// B25を経由させる。
			if (args.b25) {
				static int f_b25_sync = 0;
				try {
					uint8_t *b25buf;
					b25dec.put(buf, rlen);
					rlen = b25dec.get((const uint8_t **)&b25buf);
					if (0 == rlen) {
						continue;
					}
					f_b25_sync = 1;
					buf = b25buf;
				} catch (b25_error& e) {
					if( f_b25_sync == 0 && args.sync ){
						log << "Wait for B25 sync" << std::endl;
						continue;
					}
					log << "B25 Error: " << e.what() << std::endl;
					log << "Continue recording without B25." << std::endl;
#ifdef HTTP
					if (!args.http_mode) {
#endif /* defined(HTTP) */
					// b25停止、戻り値エラー
					args.b25 = false;
					result = 1;
#ifdef HTTP
					}
#endif /* defined(HTTP) */
				}
			}
#endif /* defined(B25) */

#ifdef TSSL
			if (args.splitter) {
				splitbuf.size = 0;
				while (rlen) {
					/* 分離対象PIDの抽出 */
					if (split_select_finish != TSS_SUCCESS) {
						split_select_finish = split_select(splitter, buf, rlen);
						if (split_select_finish == TSS_NULL) {
							/* mallocエラー発生 */
							log << "split_select malloc failed" << std::endl;
							args.splitter = false;
							result = 1;
							goto fin;
						} else if (split_select_finish != TSS_SUCCESS) {
							// 分離対象PIDが完全に抽出できるまで出力しない
							// 1秒程度余裕を見るといいかも
							time_t cur_time;
							time(&cur_time);
							if (cur_time - time_start > 4) {
								args.splitter = false;
								result = 1;
								goto fin;
							}
							break;
						}
					}
					/* 分離対象以外をふるい落とす */
					code = split_ts(splitter, buf, rlen, &splitbuf);
					if (code != TSS_SUCCESS) {
						log << "split_ts failed" << std::endl;
						break;
					}
					break;
				}

				rlen = splitbuf.size;
				buf = splitbuf.buffer;
			fin:
				;
			}
#endif /* defined(TSSL) */

#ifdef UDP
			// UDP 配信
			udp.send(buf, rlen);
#endif /* defined(UDP) */

#ifdef HTTP
			while(rlen > 0) {
				ssize_t wc;
				int ws = rlen < SIZE_CHUNK ? rlen : SIZE_CHUNK;
				while(ws > 0) {
					wc = write(dest, buf, ws);
					if(wc < 0) {
						log << "write failed." << std::endl;
						rlen = 0;
						buf = NULL;
						break;
					}
					ws -= wc;
					rlen -= wc;
					buf += wc;
				}
			}
#else
			fwrite(buf, 1, rlen, dest);
#endif /* defined(HTTP) */

		} catch (usb_error& e) {
			if (urb_error_cnt <= URB_ERROR_MAX) {
				log << e.what() << std::endl;
				if (urb_error_cnt == URB_ERROR_MAX) {
					log << "Too many URB error." << std::endl;
				}
				urb_error_cnt++;
			}
		}
	}
	if (caughtSignal) {
#ifdef HTTP
		if( args.http_mode )
			caughtSignal = false;
		else
#endif /* defined(HTTP) */
		log << "interrupted." << std::endl;
	}
	// 受信スレッド停止
	tuner->stopStream();
	
	// シグナルハンドラを戻す。
	sigaction(SIGINT,  &saDefault, NULL);
	sigaction(SIGTERM, &saDefault, NULL);
	sigaction(SIGPIPE, &saDefault, NULL);

	rlen = 0;
	buf = NULL;

#ifdef B25
	// B25デコーダ内のデータを出力する。
	if (args.b25) {
		try {
			b25dec.flush();
			rlen = b25dec.get((const uint8_t **)&buf);
		} catch (b25_error& e) {
			log << "B25 Error: " << e.what() << std::endl;
			result = 1;
		}
	}
#endif /* defined(B25) */
#ifdef TSSL
	if (args.splitter) {
		splitbuf.size = 0;
		while (rlen) {
			/* 分離対象PIDの抽出 */
			if (split_select_finish != TSS_SUCCESS) {
				split_select_finish = split_select(splitter, buf, rlen);
				if (split_select_finish == TSS_NULL) {
					/* mallocエラー発生 */
					log << "split_select malloc failed" << std::endl;
					args.splitter = false;
					result = 1;
					break;
				} else if (split_select_finish != TSS_SUCCESS) {
					// 分離対象PIDが完全に抽出できるまで出力しない
					// 1秒程度余裕を見るといいかも
					time_t cur_time;
					time(&cur_time);
					if (cur_time - time_start > 4) {
						args.splitter = false;
						result = 1;
					}
					break;
				}
			}
			/* 分離対象以外をふるい落とす */
			code = split_ts(splitter, buf, rlen, &splitbuf);
			if (code != TSS_SUCCESS) {
				log << "split_ts failed" << std::endl;
				break;
			}
			break;
		}
		rlen = splitbuf.size;
		buf = splitbuf.buffer;
		split_shutdown(splitter);
	}
#endif /* defined(TSSL) */
#ifdef HTTP
		while(rlen > 0) {
			ssize_t wc;
			int ws = rlen < SIZE_CHUNK ? rlen : SIZE_CHUNK;
			while(ws > 0) {
				wc = write(dest, buf, ws);
				if(wc < 0) {
					log << "write failed." << std::endl;
					rlen = 0;
					buf = NULL;
					break;
				}
				ws -= wc;
				rlen -= wc;
				buf += wc;
			}
		}
		if( args.http_mode ){
			/* close http socket */
			close(dest);
			fprintf(stderr,"connection closed. still listening at port %d\n", args.http_port);
		}else
			break;
	}
#else
	if (0 < rlen) {
		fwrite(buf, 1, rlen, dest);
	}
#endif /* defined(HTTP) */

	// 時間計測
	timeval tv_end;
	if (gettimeofday(&tv_end, NULL) < 0) {
		err(1, "gettimeofday failed.");
	}
	
	// 出力先ファイルクローズ
#ifdef HTTP
	if (!args.stdout) {
		close(dest);
	}
#else
	fflush(dest);
	if (!args.stdout) {
		fclose(dest);
	}
#endif /* defined(HTTP) */
	log << "done." << std::endl;
	
#ifdef UDP
	// UDP クローズ
	udp.shutdown();
#endif /* defined(UDP) */
	
	// 録画時間出力
	timeval rec_time;
	timersub(&tv_end, &tv_start, &rec_time);
	log << "Rec time: " << rec_time.tv_sec << "." << std::setfill('0') << std::setw(6) << rec_time.tv_usec << " sec." << std::endl;
	
	// 終了時SignalLevel出力
	try {
		float lev_after = tuner->getSignalLevel();
		log << "Signal level: " << lev_after << std::endl;
	} catch (usb_error& e) {
		log << e.what() << " ignored." << std::endl;
	}
	
	return result;
}
Beispiel #27
0
int main(int argc, char *argv[]) {
	const char *dataPath = "DATA";
	const char *savePath = ".";
	const char *levelNum = "0";
	char dataPathBuffer[256];
	char savePathBuffer[256];
	for (int i = 1; i < argc; ++i) {
		bool opt = false;
		if (strlen(argv[i]) >= 2) {
			opt |= parseOption(argv[i], "datapath=", &dataPath);
			opt |= parseOption(argv[i], "savepath=", &savePath);
			opt |= parseOption(argv[i], "levelnum=", &levelNum);
		}
		if (!opt) {
			printf(USAGE, argv[0]);
			return 0;
		}
	}
#ifdef GCW0
    debug(DBG_INFO,"Software version: %s",Game::_version);
	if(argc<=1){
	    debug(DBG_INFO, "No arguments given");
        char basepath[256];
        strcpy(basepath, getenv("HOME"));
        mkdir(basepath, 0777);
        strcat(basepath, "/.REminiscence");
        strcpy(dataPathBuffer,basepath);
        strcpy(savePathBuffer,basepath);
        strcat(dataPathBuffer, "/data");
        strcat(savePathBuffer, "/save");
        //create directory if they do not exist...
        mkdir(basepath, 0777);
        mkdir(savePathBuffer, 0777);
        mkdir(dataPathBuffer, 0777);
        dataPath=dataPathBuffer;
        savePath=savePathBuffer;
	}
#endif
	g_debugMask = DBG_INFO; // DBG_CUT | DBG_VIDEO | DBG_RES | DBG_MENU | DBG_PGE | DBG_GAME | DBG_UNPACK | DBG_COL | DBG_MOD | DBG_SFX | DBG_FILE;
	FileSystem fs(dataPath);

    SystemStub *stub = SystemStub_SDL_create();

	const int version = detectVersion(&fs);
	if (version == -1) {
#ifdef GCW0
	    //display an instruction screen
		stub->init("help", Video::GAMESCREEN_W, Video::GAMESCREEN_H,new Config());
		stub->setPalette(_instr_data_pal,256);
		stub->copyRect(0, 0,  Video::GAMESCREEN_W, Video::GAMESCREEN_H, _instr_data_map, 256);
		stub->updateScreen(0);
        while (!stub->_pi.quit) {
            stub->processEvents();
            if (stub->_pi.enter) {
                stub->_pi.enter = false;
                break;
            }
            stub->sleep(100);
        }
		delete stub;
#endif
		error("Unable to find data files, check that all required files are present");
		return -1;
	}

	Language language = detectLanguage(&fs);

	Game *g = new Game(stub, &fs, savePath, atoi(levelNum), (ResourceType)version, language);
	g->run();
	delete g;
	delete stub;
	return 0;
}
Beispiel #28
0
void
DAParseArguments(
	int argc,
	char **argv,
	DAProgramOption *options,
	int count,
	char *programDescription,
	char *versionDescription)
{
	int i, j, size;
	int found = 0;

	_daContext = DAContextInit(argc, argv);

	size = (count + DEFAULT_OPTION_COUNT) * sizeof(DAProgramOption *);
	_daContext->options         = malloc(size);
	memset(_daContext->options, 0, size);

	_daContextAddDefaultOptions();
	_daContextAddOptions(options, count);

	for (i = 1; i < argc; i++) {
		char *optStr = argv[i];

		/* Handle default options */
		if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
			printHelp(programDescription), exit(0);

		if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0)
			puts(versionDescription), exit(0);

		if (strcmp(argv[i], "-w") == 0 || strcmp(argv[i], "--windowed") == 0) {
			_daContext->windowed = 1;
			continue;
		}

		found = 0;
		/* options with a one-to-one mapping */
		for (j = 0; j < count; j++) {
			DAProgramOption *option = &options[j];

			if ((option->longForm && strcmp(option->longForm, optStr) == 0)
			    || (option->shortForm && strcmp(option->shortForm, optStr) == 0)) {

				found = 1;
				i = parseOption(option, i, argc, argv);
			}
		}

		/* mixed options */
		if (!found)
			/* XXX: Parsing all options again... */
			for (j = 0; j < count; j++) {
				DAProgramOption *option = &options[j];

				if (option->shortForm && contains(option->shortForm, optStr)) {
					found = 1;
					i = parseOption(option, i, argc, argv);
				}
			}

		if (!found) {
			printf("%s: unrecognized option '%s'\n", argv[0], argv[i]);
			printHelp(programDescription), exit(1);
		}
	}
}
Beispiel #29
0
bool Kernel::test_parseOption(std::string o, std::string& stage,
    std::string& option, std::string& value)
{
    return parseOption(o, stage, option, value);
}