Ejemplo n.º 1
0
void BadWords::OnFileUpdated(ThreadedFileWatcher *watcher) {
    RLOG() << watcher_.filename() << " has changed!";
    FILE *f = fopen(watcher_.filename().c_str(), "r");
    if (f == NULL) {
        return;
    }

    std::map<std::string, std::vector<std::string> > pairs;
    nodes_.clear();
    nodes_.push_back(MatchNode());
    bool standalone = false;
    bool wildcards = true;

    char sz[256];
    while (fgets(sz, sizeof(sz), f) != NULL) {
        int cch;
        const char *start = StripWhitespace(sz, &cch);
        if (cch == 0) {
            continue;
        }
        std::string s(start, cch);
        if (s[0] == '#') {
            continue;
        }
        if (s.find("@pairs") == 0) {
            pairs = ParsePairs(s);
            continue;
        }
        if (s.find("@standalone") == 0) {
            std::vector<std::string> parts = Split(s.c_str(), '/');
            if (parts.size() == 2) {
                if (parts[1].compare("true") == 0) {
                    standalone = true;
                }
                if (parts[1].compare("false") == 0) {
                    standalone = false;
                }
            }
            continue;
        }
        if (s.find("@wildcards") == 0) {
            std::vector<std::string> parts = Split(s.c_str(), '/');
            if (parts.size() == 2) {
                if (parts[1].compare("true") == 0) {
                    wildcards = true;
                }
                if (parts[1].compare("false") == 0) {
                    wildcards = false;
                }
            }
            continue;
        }
        AddPermutations(s, pairs, standalone, wildcards);
    }
    fclose(f);
}
Ejemplo n.º 2
0
/* initialize the output processor for this particular instantiation */
OpAlertSyslog2_Data *OpAlertSyslog2_ParseArgs(char *args)
{
    OpAlertSyslog2_Data *data;
    char **toks;
    int num_toks;
    int i;
    int header_length = -1;
    char *index;

    if(pv.verbose)
        LogMessage("Parsing %s arguments: %s\n", MODULE_NAME, args);
    
    if(!(data = (OpAlertSyslog2_Data *)calloc(1, sizeof(OpAlertSyslog2_Data))))
    {
        FatalError("Out of memory creating %s configuration\n", MODULE_NAME);
        return NULL;
    }
    data->facility = -1;
    data->severity = -1;
    data->socket = -1;

    if(args)
    {
        toks = mSplit(args, ";", 8, &num_toks, 0);  
        /* XXX error check */

        for(i = 0; i < num_toks; i++)
        {
            char *token = toks[i];
            char **subtoks;
            int num_subtoks;
            long value;
            StripWhitespace(&token);
            if(*token == '\0')
                continue;
            /* split the token on ':' */
            subtoks = mSplit(token, ":", 2, &num_subtoks, 0);  
            /* XXX error check */

            if(strcasecmp("facility", subtoks[0]) == 0)
            {
                if(data->facility >= 0)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                /* Process facility Argument */
                if(num_subtoks != 2)
                {
                    FatalError("%s: Invalid %s argument: %s\n",
                            MODULE_NAME, subtoks[0], subtoks[1]);
                }

                if(String2Long(subtoks[1], &value) == 0)
                {
                    if(value > MAX_FACILITY)
                        FatalError("%s: Invalid %s argument: %s\n"
                                MODULE_NAME, subtoks[0], subtoks[1]);
                    else
                        data->facility = value;
                }
                else
                {
                    /* search for match in facility map */
                    int j = 0;
                    while(facility_map[j].keyword)
                    {
                        if(strcasecmp(facility_map[j].keyword, subtoks[1]) == 0)
                        {
                            data->facility = facility_map[j].value;
                            break;
                        }
                        j++;
                    }
                    if(data->facility < 0)
                    {
                        FatalError("%s: Invalid %s argument: %s\n",
                                MODULE_NAME, subtoks[0], subtoks[1]);
                    }
                }
            }
            else if(strcasecmp("severity", subtoks[0]) == 0)
            {
                if(data->severity >= 0)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                /* Process severity Argument */
                if(num_subtoks != 2)
                {
                    FatalError("%s: Invalid %s argument: %s\n",
                            MODULE_NAME, subtoks[0], subtoks[1]);
                }

                if(String2Long(subtoks[1], &value) == 0)
                {
                    if(value > MAX_FACILITY)
                        FatalError("%s: Invalid %s argument: %s\n"
                                MODULE_NAME, subtoks[0], subtoks[1]);
                    else
                        data->severity = value;
                }
                else
                {
                    /* search for match in severity map */
                    int j = 0;
                    while(severity_map[j].keyword)
                    {
                        if(strcasecmp(severity_map[j].keyword, subtoks[1]) == 0)
                        {
                            data->severity = severity_map[j].value;
                            break;
                        }
                        j++;
                    }
                    if(data->severity < 0)
                    {
                        FatalError("%s: Invalid %s argument: %s\n",
                                MODULE_NAME, subtoks[0], subtoks[1]);
                    }
                }
            }
            else if(strcasecmp("hostname", subtoks[0]) == 0)
            {
                if(data->hostname)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                /* Must be < 255 bytes and must contain only alphanumeric
                 * names and embedded '-'s */
                if(IsValidHostname(subtoks[1]) != 1)
                    FatalError("%s: %s argument is not a valid hostname: %s\n",
                            MODULE_NAME, subtoks[0], subtoks[1]);

                if(!(data->hostname = strdup(subtoks[1])))
                    FatalError("%s: Out of memory processing config\n");
            }
            else if(strcasecmp("tag", subtoks[0]) == 0)
            {
                if(data->tag)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                if(IsValidSyslogTag(subtoks[1]) != 1)
                    FatalError("%s: %s argument is not a valid syslog tag: "
                            "%s\n", MODULE_NAME, subtoks[0], subtoks[1]);
                
                if(!(data->tag = strdup(subtoks[1])))
                    FatalError("%s: Out of memory processing config\n");
            }
            else if(strcasecmp("syslog_host", subtoks[0]) == 0)
            {
                if(data->syslog_host)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                if(!(data->syslog_host = strdup(subtoks[1])))
                    FatalError("%s: Out of memory processing config\n");
            }
            else if(strcasecmp("syslog_port", subtoks[0]) == 0)
            {
                if(data->syslog_port > 0)
                {
                    FatalError("%s: Multiple %s arguments\n", 
                            MODULE_NAME, subtoks[0]);
                }
                if(String2Long(subtoks[1], &value) != 0)
                    FatalError("%s: Invalid %s argument: %s\n",
                            MODULE_NAME, subtoks[0], subtoks[1]);
                
                if(value < 1 || value > 65535)
                    FatalError("%s: Invalid %s argument: %s\n",
                            MODULE_NAME, subtoks[0], subtoks[1]);

                data->syslog_port = value;

            }
            else if(strcasecmp("withpid", subtoks[0]) == 0)
            {   
                if(num_subtoks != 1)
                {
                    FatalError("%s: %s does not take arguments\n",
                            MODULE_NAME, subtoks[0]);
                }
                data->pid_flag = 1;
            }
            else
            {
                FatalError("%s: Unknown argument: %s\n",
                        MODULE_NAME, subtoks[0]);
            }

            FreeToks(subtoks, num_subtoks);
        }

        FreeToks(toks, num_toks);
    }

    if(data->facility == -1)
        data->facility = DEFAULT_FACILITY;
    if(data->severity == -1)
        data->severity = DEFAULT_SEVERITY;
    if(!data->tag)
    {
        if(!(data->tag = strdup(PROGRAM_NAME)))
            FatalError("%s: Out of memory processing config\n");
    }
    if(!data->hostname)
    {
        char hostname[255];
        char *index;
        if(gethostname(hostname, 255) != 0)
            FatalError("%s: Unable to get hostname\n");
        /* since we may get a FQDN, munge the hostname */
        if((index = strchr(hostname, '.')))
            *index = '\0';

        if(!(data->hostname = strdup(hostname)))
            FatalError("%s: Out of memory processing config\n");
    }
    if(!data->syslog_host)
    {
        if(!(data->syslog_host = strdup(DEFAULT_SYSLOG_HOST)))
            FatalError("%s: Out of memory processing config\n");
    }
    if(data->syslog_port == 0)
        data->syslog_port = DEFAULT_SYSLOG_PORT;
    
    /* calculate the syslog priority */
    data->priority = data->facility * 8 + data->severity;

    /* allocate the message buffer */
    if(!(data->message_buffer = calloc(MESSAGE_LENGTH, sizeof(char))))
        FatalError("%s: Out of memory starting output plugin\n");

    /* copy in the basic string */
    if(data->pid_flag)
        header_length = snprintf(data->message_buffer, MESSAGE_LENGTH, 
                "<%u>XXX XX XX:XX:XX %s %s[%u]: ",
                data->priority, data->hostname, data->tag, getpid());
    else
        header_length = snprintf(data->message_buffer, MESSAGE_LENGTH, 
                "<%u>XXX XX XX:XX:XX %s %s: ", 
                data->priority, data->hostname, data->tag);

    if(header_length > MESSAGE_LENGTH)
        FatalError("%s: Message header length is too long: %i\n", 
                header_length);

    data->header_length = header_length;

    if(!(index = strchr(data->message_buffer, '>')))
        FatalError("%s: Error calculating priority field length\n");

    data->month_offset = index - data->message_buffer + 1;
    data->timestamp_offset = data->month_offset + 4;
    
        
    if(pv.verbose)
    {
    }
    
    return data;
}
Ejemplo n.º 3
0
static bool CreateDictionaryFromXMLRecursive(char *data, int size, CFMutableDictionaryRef *dict,
        char *key)
{

    if (size == 0) return true;

    xml_token tok;
    char *buf = data;
    int bytesleft = size, closeindex;
    bool bClosed, bAllocatedKey = false;

    while (bytesleft) {

        // skip whitespace
        if (isspace(buf[0])) {
            buf++;
            bytesleft--;
            continue;
        }

        bClosed = false;
        closeindex = -1;

        // get XML token
        if (!GetNextToken(&buf, &bytesleft, &tok, &bClosed)) {

            if (bAllocatedKey) free(key);

            return false;
        }

        // closed XML token?
        if (bClosed) {

            if (key == NULL) continue;

            if (*dict == NULL) {

                if (bAllocatedKey) free(key);

                return false;
            }

            CFBooleanRef value = NULL;

            if (!strcasecmp(tok.id, "true")) {
                value = kCFBooleanTrue;
            }
            else if (!strcasecmp(tok.id, "false")) {
                value = kCFBooleanFalse;
            }

            if (value != NULL) {
                CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault,
                                    key, kCFStringEncodingUTF8);

                if (bAllocatedKey) {
                    free(key);
                    key = NULL;
                    bAllocatedKey = false;
                }

                if (cfkey == NULL) {
                    return false;
                }

                CFDictionaryAddValue(*dict, cfkey, value);
            }
            else if (bAllocatedKey) {
                free(key);
                key = NULL;
                bAllocatedKey = false;
            }

            continue;
        }

        // check for token types we know about
        if (!strcasecmp(tok.id, "key")) {

            if (bAllocatedKey) free(key);

            if (*dict == NULL) return false;

            closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "key");

            if (closeindex == -1) return false;

            key = (char*)malloc(closeindex+1);
            strncpy(key, buf, closeindex);
            key[closeindex] = 0;
            StripWhitespace(&key);
#ifdef DEBUG
            printf("key = %s\n", key);
#endif

            // empty keys are not allowed
            if (strlen(key) == 0) {
                free(key);
                return false;
            }

            bAllocatedKey = true;
            buf += closeindex + 6;
            bytesleft -= closeindex + 6;
        }
        else if (!strcasecmp(tok.id, "dict")) {

            if (key == NULL) {

                if (*dict != NULL) return false;

                closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "dict");

                if (closeindex == -1) {
                    return false;
                }

                *dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
                                                  &kCFTypeDictionaryKeyCallBacks,
                                                  &kCFTypeDictionaryValueCallBacks);

                if (*dict == NULL) {
                    return false;
                }

                if (!CreateDictionaryFromXMLRecursive(buf, closeindex, dict, NULL)) {
                    CFRelease(*dict);
                    return false;
                }

                return true;
            }
            else if (*dict != NULL) {
                closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "dict");

                if (closeindex == -1) {

                    if (bAllocatedKey) free(key);

                    return false;
                }

                CFMutableDictionaryRef dict2 = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
                                               &kCFTypeDictionaryKeyCallBacks,
                                               &kCFTypeDictionaryValueCallBacks);

                if (dict2 == NULL) {

                    if (bAllocatedKey) free(key);

                    return false;
                }

                if (!CreateDictionaryFromXMLRecursive(buf, closeindex, &dict2, NULL)) {

                    if (bAllocatedKey) free(key);

                    CFRelease(dict2);
                    return false;
                }

                CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault,
                                    key, kCFStringEncodingUTF8);

                if (bAllocatedKey) {
                    free(key);
                    key = NULL;
                    bAllocatedKey = false;
                }

                if (cfkey == NULL) {
                    CFRelease(dict2);
                    return false;
                }

                CFDictionaryAddValue(*dict, cfkey, dict2);

                buf += closeindex + 7;
                bytesleft -= closeindex + 7;
            }
            else {

                if (bAllocatedKey) free(key);

                return false;
            }

        }
        else if (!strcasecmp(tok.id, "data")) {

            if ( (key == NULL) || (*dict == NULL) ) return false;

            closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "data");

            if (closeindex == -1) {

                if (bAllocatedKey) free(key);

                return false;
            }

            CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault,
                                key, kCFStringEncodingUTF8);

            if (bAllocatedKey) {
                free(key);
                key = NULL;
                bAllocatedKey = false;
            }

            if (cfkey == NULL) {
                return false;
            }

            char *value = (char*)malloc(closeindex+1);
            strncpy(value, buf, closeindex);
            value[closeindex] = 0;
            StripWhitespace(&value);

            if (strlen(value) > 0) {
                // Base64 decode the data
                int decodelen = Base64decode_len(value);

                if (decodelen > 0) {
                    char *decodedval = (char*)malloc(decodelen);
                    Base64decode(decodedval, value);
                    free(value);
                    value = decodedval;
                }

            }

            CFDataRef cfvalue = CFDataCreate(kCFAllocatorDefault, (const UInt8*)value, strlen(value));
            free(value);

            if (cfvalue == NULL) {
                return false;
            }

            CFDictionaryAddValue(*dict, cfkey, cfvalue);

            buf += closeindex + 7;
            bytesleft -= closeindex + 7;
        }
        else if (!strcasecmp(tok.id, "string")) {

            if ( (key == NULL) || (*dict == NULL) ) return false;

            closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "string");

            if (closeindex == -1) {

                if (bAllocatedKey) free(key);

                return false;
            }

            CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault,
                                key, kCFStringEncodingUTF8);

            if (bAllocatedKey) {
                free(key);
                key = NULL;
                bAllocatedKey = false;
            }

            if (cfkey == NULL) {
                return false;
            }

            char *value = (char*)malloc(closeindex+1);
            strncpy(value, buf, closeindex);
            value[closeindex] = 0;
            StripWhitespace(&value);
#ifdef DEBUG
            printf("string = %s\n", value);
#endif

            CFStringRef cfvalue = CFStringCreateWithCString(kCFAllocatorDefault,
                                  value, kCFStringEncodingUTF8);
            free(value);

            if (cfvalue == NULL) {
                return false;
            }

            CFDictionaryAddValue(*dict, cfkey, cfvalue);

            buf += closeindex + 9;
            bytesleft -= closeindex + 9;
        }
        else if (!strcasecmp(tok.id, "?xml") || !strcasecmp(tok.id, "!DOCTYPE") ||
                 !strcasecmp(tok.id, "plist")) {
            // Ignore
        }
        else {

            // unknown token -- just skip it
            if (bAllocatedKey) {
                free(key);
                key = NULL;
                bAllocatedKey = false;
            }

            closeindex = PIGetIndexOfClosingTag(buf, bytesleft, tok.id);

            if (closeindex == -1) {
                return false;
            }

            buf += closeindex + strlen(tok.id) + 3;
            bytesleft -= closeindex + strlen(tok.id) + 3;
        }

    }

    if (bAllocatedKey) free(key);

    return true;
}
Ejemplo n.º 4
0
void CModelConverter::ReadMTL(const tstring& sFilename)
{
	FILE* fp = tfopen(sFilename, _T("r"));

	if (!fp)
		return;

	if (m_pWorkListener)
		m_pWorkListener->SetAction(_T("Reading materials"), 0);

	size_t iCurrentMaterial = ~0;

	tstring sLine;
	while (fgetts(sLine, fp))
	{
		sLine = StripWhitespace(sLine);

		if (sLine.length() == 0)
			continue;

		if (sLine[0] == '#')
			continue;

		eastl::vector<tstring> asTokens;
		tstrtok(sLine, asTokens, _T(" "));
		const tchar* pszToken = NULL;
		pszToken = asTokens[0].c_str();

		CConversionMaterial* pMaterial = NULL;
		if (iCurrentMaterial != ~0)
			pMaterial = m_pScene->GetMaterial(iCurrentMaterial);

		if (tstrncmp(pszToken, _T("newmtl"), 6) == 0)
		{
			pszToken = asTokens[1].c_str();
			CConversionMaterial oMaterial(pszToken, Vector(0.2f,0.2f,0.2f), Vector(0.8f,0.8f,0.8f), Vector(1,1,1), Vector(0,0,0), 1.0, 0);
			iCurrentMaterial = m_pScene->AddMaterial(oMaterial);
		}
		else if (tstrncmp(pszToken, _T("Ka"), 2) == 0)
		{
			eastl::vector<tstring> asTokens;
			tstrtok(sLine, asTokens, _T(" "));
			if (asTokens.size() == 4)
			{
				pMaterial->m_vecAmbient.x = stof(asTokens[1]);
				pMaterial->m_vecAmbient.y = stof(asTokens[2]);
				pMaterial->m_vecAmbient.z = stof(asTokens[3]);
			}
		}
		else if (tstrncmp(pszToken, _T("Kd"), 2) == 0)
		{
			eastl::vector<tstring> asTokens;
			tstrtok(sLine, asTokens, _T(" "));
			if (asTokens.size() == 4)
			{
				pMaterial->m_vecDiffuse.x = stof(asTokens[1]);
				pMaterial->m_vecDiffuse.y = stof(asTokens[2]);
				pMaterial->m_vecDiffuse.z = stof(asTokens[3]);
			}
		}
		else if (tstrncmp(pszToken, _T("Ks"), 2) == 0)
		{
			eastl::vector<tstring> asTokens;
			tstrtok(sLine, asTokens, _T(" "));
			if (asTokens.size() == 4)
			{
				pMaterial->m_vecSpecular.x = stof(asTokens[1]);
				pMaterial->m_vecSpecular.y = stof(asTokens[2]);
				pMaterial->m_vecSpecular.z = stof(asTokens[3]);
			}
		}
		else if (tstrncmp(pszToken, _T("d"), 1) == 0 || tstrncmp(pszToken, _T("Tr"), 2) == 0)
		{
			pMaterial->m_flTransparency = (float)stof(asTokens[1]);
		}
		else if (tstrncmp(pszToken, _T("Ns"), 2) == 0)
		{
			pMaterial->m_flShininess = (float)stof(asTokens[1])*128/1000;
		}
		else if (tstrncmp(pszToken, _T("illum"), 5) == 0)
		{
			pMaterial->m_eIllumType = (IllumType_t)stoi(asTokens[1]);
		}
		else if (tstrncmp(pszToken, _T("map_Kd"), 6) == 0)
		{
			pszToken = asTokens[1].c_str();

			FILE* fpTest = tfopen(pszToken, _T("r"));

			if (fpTest)
			{
				fclose(fpTest);

				pMaterial->m_sDiffuseTexture = tstring(pszToken);
			}
			else
			{
				tstring sDirectory = GetDirectory(sFilename);

				pMaterial->m_sDiffuseTexture = sprintf(tstring("%s/%s"), sDirectory.c_str(), pszToken);
			}
		}
	}

	fclose(fp);
}
Ejemplo n.º 5
0
void Target::ImportFile(string filename, string comment_chars)
{
	vector <string> lines = ReadFile(filename, comment_chars, "Cannot Open Target Definition File");
	vector <string> results;

	int max_params = 9;
	int n_params = 0;

	for(unsigned int i = 0; i < lines.size(); i++)
	{
		// Clear out the results, split the string and strip whitespace
        results.clear();
//        StringSplit(lines[i], string("="), results);
        results = SplitString(lines[i], '=');
        StripWhitespace(results);

        // Now we parse the file by keyword
        if(results[0] == "name")
        {
        	this->name = string(results[1]);
        	n_params += 1;
        }

        if(results[0] == "res")
        {
        	try
        	{
        		this->pixellation = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid Pixellation Definition in Target File");
        	}
        }

        if(results[0] == "mag")
        {
        	try
        	{
        		this->mag = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid Magnitude Definition in Target File");
        	}
        }

        if(results[0] == "band")
        {
        	try
        	{
        		this->band = results[1][0];
				n_params += 1;
			}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid Band Definition in Target File");
        	}
        }

        if(results[0] == "temp")
        {
        	try
        	{
        		this->temperature = atof(results[1].c_str());
				n_params += 1;
			}
        	catch(...)
			{
        		throw std::runtime_error("Invalid Temperature Definition in Target File");
			}
        }

        if(results[0] == "bkgrnd")
        {
        	try
        	{
        		this->background = atof(results[1].c_str());
				n_params += 1;
			}
        	catch(...)
			{
        		throw std::runtime_error("Invalid Background Definition in Target File");
			}
        }

        if(results[0] == "bkgrnd_ap")
        {
        	try
        	{
        		this->background_ap = atof(results[1].c_str());
				n_params += 1;
			}
        	catch(...)
			{
        		throw std::runtime_error("Invalid Background Definition in Target File");
			}
        }

        if(results[0] == "src_dec")
        {
        	try
        	{
        		this->declination = atof(results[1].c_str()) * PI / 180;
				n_params += 1;
			}
        	catch(...)
			{
        		throw std::runtime_error("Invalid source declination Target File");
			}
        }

        if(results[0] == "src_ra")
        {
        	try
        	{
        		this->right_ascension = atof(results[1].c_str()) * PI / 180;
				n_params += 1;
			}
        	catch(...)
			{
        		throw std::runtime_error("Invalid source right ascention Target File");
			}
        }

	}

	if(n_params != max_params)
		throw std::runtime_error("The Target file is missing some parameters.  Please check the file.");

	// Now, init the flux.
	this->InitFlux();
}
Ejemplo n.º 6
0
// Create and initialize an array from data given in a text file.
void Array::ImportFile(string filename, string comment_chars)
{
	// Some local variables
	int max_params = 8; // This is the number of non-telescope parameters found in the array definition file.
	int n_params = 0; // the number of parameters read in from the file

    // Local varaibles for creating Station objects.
    string staname;
    int sta_index;
    double North;
    double East;
    double Up;
    double gain;
    double diameter;
    int coord_sys;
    bool xyz_coords = false;

    int line_number;

    // We permit shortcuts in the name of the arrays, this lets us do
    // $ oifits-sim -a CHARA
    // instead of
    // $ oifits-sim -a /home/.../etc/CHARA.txt
    // which I think is a nice feature.  To do this, we first need to see if a file with the
    // name, filename, really exists.
    // TODO: Use a global variable, read in from a configuration file, to specify "../etc" below.
    if(!FileExists(filename))
    {
    	filename = "../etc/" + filename + ".txt";
    }

    // stores non-blank, non-comment lines
    vector < string > lines = ReadFile(filename, comment_chars, "Cannot Open Array Definition File");
	vector <string> results;

	for(line_number = 0; line_number < max_params; line_number++)
	{
		// Clear out the results, split the string and strip whitespace
        results.clear();
        results = SplitString(lines[line_number], '=');
        StripWhitespace(results);


        if(results[0] == "name")
        {
        	try
        	{
        		this->arrayname = string(results[1]);
        		n_params += 1;
        		cout << "Loading Array " << this->arrayname << endl;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array name");
        	}
        }

        if(results[0] == "lat")
        {
        	try
        	{
        		this->latitude = atof(results[1].c_str());

        		// Convert to radians:
                this->latitude *= PI / 180;
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array latitude");
        	}
        }

        if(results[0] == "lon")
        {
        	try
        	{
        		this->longitude = atof(results[1].c_str());

        		// Convert to radians:
                this->longitude *= PI / 180;
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array longitude");
        	}
        }

        if(results[0] == "alt")
        {
        	try
        	{
        		this->altitude = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array altitude");
        	}
        }

        if(results[0] == "coord")
        {
        	try
        	{
                coord_sys = atoi(results[1].c_str());
                if(coord_sys == 0)
                {
                    cout << "Array Coordinate system specified in XYZ." << endl;
                    xyz_coords = true;
                }
                else
                    cout << "Array Coordinate system specified in (North, East, Up)." << endl;

        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid Coordinate definition specification for telescope positions.");
        	}
        }

        if(results[0] == "throughput")
        {
        	try
        	{
        		this->throughput = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array throughput");
        	}
        }

        if(results[0] == "wind_speed")
        {
        	try
        	{
        		// Import the wind speed.  In the input parameter file it is in m/s
        		// all variables are stored in MKS units, so no conversion is necessary.
        		this->wind_speed = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid array average wind speed");
        	}
        }

        if(results[0] == "r0")
        {
        	try
        	{
        		this->r0 = atof(results[1].c_str());
        		n_params += 1;
        	}
        	catch(...)
        	{
        		throw std::runtime_error("Invalid average r0 for the array");
        	}
        }
	}

	// Do some quick error checking on the file format.  First, make sure we've got all of the parameters:
	if(n_params != max_params)
		throw std::runtime_error("Parameters are missing from the array definition file.");

	// Now double-check that there are at least two telescopes in this array
	// This is represented by at least two lines remaining in the file.
	if(lines.size() - line_number < 2)
		throw std::runtime_error("At least two telescopes are required for an array!  Check configuration file.");

    // Now iterate through the telescope definitions.  There are four entries above
    // this point in the data file so we start at 4.
    for (unsigned int i = line_number; i < lines.size(); i++)
    {
    	// First tokenize the line
    	vector < string > tokens = Tokenize(lines[i]);

    	// And now attempt to read in the line
    	try
    	{
			staname = tokens[0];
			sta_index = atoi(tokens[1].c_str());
			North = atof(tokens[2].c_str());
			East = atof(tokens[3].c_str());
			Up = atof(tokens[4].c_str());
			gain = atof(tokens[5].c_str());
			diameter = atof(tokens[6].c_str());
    	}
    	catch(...)
    	{
    		throw std::runtime_error("Error in telecope definitions in array configuration file.");
    	}
        
        // Push this station on to the list of stations for this array.
        this->stations.push_back( Station(this->latitude, staname, sta_index, xyz_coords, North, East, Up, gain, diameter) );
    }
    
    // Compute a hash table for the stations:
    this->sta_hash = ComputeStationHash(stations);
    
    // Now compute all possible baselines from these stations.
    this->baselines = ComputeBaselines(stations);
    this->bl_hash = ComputeBaselineHash(this->baselines);
    this->triplets = ComputeTriplets(this, stations);
    this->tri_hash = ComputeTripletHash(this->triplets);
    this->quadruplets = ComputeQuadruplets(this, stations);
    this->quad_hash = ComputeQuadrupletHash(this->quadruplets);

}
Ejemplo n.º 7
0
static int ReadTmBbs(char *pchFileName, char *TmBbsName, char *NetmailPath,
                     USERDATAOPT *pUserData, PDRIVEREMAP pDriveRemap, PAREALIST pRetList, PDESCLIST pDescList)
{
   char pchBBSName[LEN_USERNAME+1];
   FILE *pfBBS;
   AREADEFOPT Area;

   if (NetmailPath[0])
      AddNetmailArea(&Area, pchFileName, NetmailPath, pUserData, pRetList);

   if (TmBbsName[0] && TmBbsName[1] == ':')
   {
      /* voller Name */
      strcpy(pchBBSName, TmBbsName);
      MSG_RemapDrive(pchBBSName, pDriveRemap);
   }
   else
   {
      /* Teil-Name */
      CopyPath(pchBBSName, pchFileName);
      strcat(pchBBSName, "\\");
      strcat(pchBBSName, TmBbsName);
   }

   pfBBS = fopen(pchBBSName, "r");

   if (pfBBS)
   {
      char zeile[200];
      char *pchTemp;

      while (!feof(pfBBS))
      {
         if (fgets(zeile, sizeof(zeile), pfBBS))
         {
            StripWhitespace(zeile);
            if (zeile[0] && zeile[0] != '@')
            {
               BOOL bNotValid = FALSE;

               memset(&Area, 0, sizeof(Area));
               Area.areaformat = AREAFORMAT_FTS; /* Default */
               Area.areatype = AREATYPE_ECHO;    /* Default */
               strcpy(Area.username, pUserData->username[0]);
               strcpy(Area.address, pUserData->address[0]);
               Area.ulAreaOpt = AREAOPT_FROMCFG;

               /* Pfad ermitteln */
               pchTemp = strtok(zeile, " \t");

               if (pchTemp)
               {
                  if (pchTemp[0] && pchTemp[1] == ':')
                     /* voller Pfad */
                     strncpy(Area.pathfile, pchTemp, LEN_PATHNAME);
                  else
                  {
                     /* relativer pfad */
                     CopyPath(Area.pathfile, pchFileName);
                     strcat(Area.pathfile, "\\");
                     strcat(Area.pathfile, pchTemp);
                     Area.ulTempFlags = AREAFLAG_NOREMAP;
                  }
                  RemoveBackslash(Area.pathfile);

                  if (pchTemp = strtok(NULL, " \t"))
                  {
                     PDESCLIST pDesc = pDescList;

                     strncpy(Area.areatag, pchTemp, LEN_AREATAG);

                     /* Description suchen */
                     while (pDesc && stricmp(pDesc->pchAreaTag, pchTemp))
                        pDesc = pDesc->next;

                     if (pDesc)
                        strcpy(Area.areadesc, pDesc->pchDesc);
                     else
                        strncpy(Area.areadesc, pchTemp, LEN_AREADESC);

                     while (pchTemp = strtok(NULL, " \t"))
                     {
                        if (!stricmp(pchTemp, "JAM"))
                           Area.areaformat = AREAFORMAT_JAM;
                        else
                           if (!stricmp(pchTemp, "HOLD"))
                              Area.areatype = AREATYPE_LOCAL;
                           else
                              if (!stricmp(pchTemp, "QWK"))
                              {
                                 bNotValid = TRUE;
                                 break;
                              }
                     }
                     if (!bNotValid)
                        AM_AddArea(pRetList, &Area, ADDAREA_TAIL | ADDAREA_UNIQUE);
                  }
               }
            }
         }
         else
            if (ferror(pfBBS))
            {
               fclose(pfBBS);
               return CFGFILE_READ;
            }
      }
      fclose(pfBBS);
      return CFGFILE_OK;
   }
   else
      return CFGFILE_OPEN;
}
Ejemplo n.º 8
0
static int ReadTmCfg(char *pchFileName,
                     char *pchNameBuffer, char *pchOutbound,
                     char *pchNetmail, USERDATAOPT *pUserData, PDESCLIST *ppDescList)
{
   FILE *pfTmCfg;
   char zeile[200];

   pfTmCfg=fopen(pchFileName, "r");

   if (pfTmCfg)
   {
      while (!feof(pfTmCfg))
      {
         if (fgets(zeile, sizeof(zeile), pfTmCfg))
         {
            /* Whitespace u. Kommentare entfernen */
            StripWhitespace(zeile);

            if (zeile[0]) /* Zeile m. Inhalt */
            {
               char *pchKeyword;
               char *pchParam, *pchParam2;
               char *pchDup = strdup(zeile);

               pchKeyword = strtok(zeile, " \t");

               if (pchKeyword)
               {
                  pchParam = strtok(NULL, " \t");

                  switch(QueryKeyword(pchKeyword))
                  {
                     case KEY_NETMAIL:
                        if (!pchNetmail[0] && pchParam)
                        {
                           strcpy(pchNetmail, pchParam);
                           RemoveBackslash(pchOutbound);
                        }
                        break;

                     case KEY_OUTBOUND:
                        if (!pchOutbound[0] && pchParam)
                        {
                           strcpy(pchOutbound, pchParam);
                           RemoveBackslash(pchOutbound);
                        }
                        break;

                     case KEY_AREAFILE:
                        if (!pchNameBuffer[0] && pchParam)
                           strcpy(pchNameBuffer, pchParam);
                        break;

                     case KEY_ORIGIN:
                        if (pchParam)
                           AddOrigin(pUserData, pchDup);
                        break;

                     case KEY_NAME:
                        if (pchParam)
                           AddName(pUserData, pchDup);
                        break;

                     case KEY_ADDRESS:
                        if (pchParam)
                           AddAddress(pUserData, pchParam);
                        break;

                     case KEY_ADESC:
                        if (ppDescList)
                        {
                           pchParam2 = strtok(NULL, " \t");
                           if (pchParam2)
                           {
                              PDESCLIST pNewDesc;
                              pNewDesc = calloc(1, sizeof(DESCLIST));
                              if (pNewDesc)
                              {
                                 char *pchTemp;

                                 /* vorne einhaengen */
                                 pNewDesc->next = *ppDescList;
                                 *ppDescList = pNewDesc;

                                 /* Daten */
                                 strncpy(pNewDesc->pchAreaTag, pchParam, LEN_AREATAG);
                                 strncpy(pNewDesc->pchDesc, pchParam2, LEN_AREADESC);

                                 /* _ umwandeln */
                                 pchTemp = pNewDesc->pchDesc;
                                 while (*pchTemp)
                                 {
                                    if (*pchTemp == '_')
                                       *pchTemp = ' ';
                                    pchTemp++;
                                 }
                              }
                           }
                        }
                        break;

                     default:
                        /* unbekannt/unbehandelt */
                        break;
                  }
               }
               free(pchDup);
            }
         }
         else
            if (ferror(pfTmCfg))
            {
               /* Fehler beim Lesen der Datei */
               fclose(pfTmCfg);

               return CFGFILE_READ;
            }
      }
      fclose(pfTmCfg);

      return CFGFILE_OK;
   }
   else
      return CFGFILE_OPEN;
}