void skip_segment(FILE * movie)
{
union {
uint16_t segment_size;
uint8_t size[2];
} u;
/* tokens are followed by the size of their section, on 16bits */
NEXT_TOKEN(u.size[0]);
NEXT_TOKEN(u.size[1]);
CPU_DATA_IS_BIGENDIAN(16, u.segment_size);
IPRINTF("Skip segment (%d data)\r\n", (unsigned int) u.segment_size);
SKIP(u.segment_size - 2);
}
static int accept(ApexParser *parser, ApexToken tk) {
if (GET_TOKEN(parser) != tk) {
return 0;
}
parser->value = apex_lexer_get_value(parser->lexer);
NEXT_TOKEN(parser);
return 1;
}
static int expect(ApexParser *parser, ApexToken exp) {
ApexToken tk = GET_TOKEN(parser);
if (tk == exp) {
parser->value = apex_lexer_get_value(parser->lexer);
NEXT_TOKEN(parser);
return 1;
}
unexp(parser, 1, exp);
return 0;
}
/*
* Ancienne version de load_huffman.
* On ne devrait plus en avoir besoin, mais le main appelle encore
* cette version.
*/
int load_huffman_table_size(FILE * movie,
uint16_t DHT_section_length,
uint8_t DHT_section_info,
huff_table_t * ht)
{
uint8_t buffer = 0;
int32_t size = 0, i = 0, j = 0;
uint8_t num_values[16];
huff_table_t *current_ptr = NULL;
// ht est la racine de l'arbre
// rien d'autre n'est alloué !!!
ht->code = 0;
ht->value = 0;
ht->is_elt = 0;
ht->parent = NULL;
ht->left = NULL;
ht->right = NULL;
// récupération des longueurs :
for (i=0 ; i < 16 ; i++) {
NEXT_TOKEN(buffer);
num_values[i] = buffer;
}
size = 16;
for (i = 0 ; i < 16 ; i++) {
for (j = 0 ; j < num_values[i] ; j++) {
current_ptr = find_location(ht, i+1);
if(current_ptr == NULL) {
printf("Oops ! No location found, exiting...\n");
return -1;
}
size++;
NEXT_TOKEN(buffer);
current_ptr->value = buffer;
APRINTF("Value %02x has code %02x(%d)\n", buffer, current_ptr->code,i+1);
current_ptr->is_elt = 1;
}
}
return (size);
}
/* program
* : module_spec
* | program func_decl
* | program import
* | block
*/
static void program(ApexParser *parser) {
ApexToken tk = NEXT_TOKEN(parser);
/* module_spec(parser); */
do {
tk = GET_TOKEN(parser);
switch (tk) {
case APEX_TOKEN_IMPORT:
import(parser);
break;
default:
block(parser);
break;
}
tk = GET_TOKEN(parser);
} while (tk != APEX_TOKEN_EOS);
}
VCardEmulOptions *
vcard_emul_options(const char *args)
{
int reader_count = 0;
VCardEmulOptions *opts;
/* Allow the future use of allocating the options structure on the fly */
memcpy(&options, &default_options, sizeof(options));
opts = &options;
do {
args = strip(args); /* strip off the leading spaces */
if (*args == ',') {
continue;
}
/* soft=(slot_name,virt_name,emul_type,emul_flags,cert_1, (no eol)
* cert_2,cert_3...) */
if (strncmp(args, "soft=", 5) == 0) {
const char *name;
size_t name_length;
const char *vname;
size_t vname_length;
const char *type_params;
size_t type_params_length;
char type_str[100];
VCardEmulType type;
int count, i;
VirtualReaderOptions *vreaderOpt = NULL;
args = strip(args + 5);
if (*args != '(') {
continue;
}
args = strip(args+1);
NEXT_TOKEN(name)
NEXT_TOKEN(vname)
NEXT_TOKEN(type_params)
type_params_length = MIN(type_params_length, sizeof(type_str)-1);
pstrcpy(type_str, type_params_length, type_params);
type = vcard_emul_type_from_string(type_str);
NEXT_TOKEN(type_params)
if (*args == 0) {
break;
}
if (opts->vreader_count >= reader_count) {
reader_count += READER_STEP;
vreaderOpt = realloc(opts->vreader,
reader_count * sizeof(*vreaderOpt));
if (vreaderOpt == NULL) {
return opts; /* we're done */
}
}
opts->vreader = vreaderOpt;
vreaderOpt = &vreaderOpt[opts->vreader_count];
vreaderOpt->name = g_strndup(name, name_length);
vreaderOpt->vname = g_strndup(vname, vname_length);
vreaderOpt->card_type = type;
vreaderOpt->type_params =
g_strndup(type_params, type_params_length);
count = count_tokens(args, ',', ')') + 1;
vreaderOpt->cert_count = count;
vreaderOpt->cert_name = (char **)g_malloc(count*sizeof(char *));
for (i = 0; i < count; i++) {
const char *cert = args;
args = strpbrk(args, ",)");
vreaderOpt->cert_name[i] = g_strndup(cert, args - cert);
args = strip(args+1);
}
if (*args == ')') {
args++;
}
opts->vreader_count++;
/* use_hw= */
} else if (strncmp(args, "use_hw=", 7) == 0) {
args = strip(args+7);
if (*args == '0' || *args == 'N' || *args == 'n' || *args == 'F') {
opts->use_hw = PR_FALSE;
} else {
opts->use_hw = PR_TRUE;
}
args = find_blank(args);
/* hw_type= */
} else if (strncmp(args, "hw_type=", 8) == 0) {
args = strip(args+8);
opts->hw_card_type = vcard_emul_type_from_string(args);
args = find_blank(args);
/* hw_params= */
} else if (strncmp(args, "hw_params=", 10) == 0) {
const char *params;
args = strip(args+10);
params = args;
args = find_blank(args);
opts->hw_type_params = g_strndup(params, args-params);
/* db="/data/base/path" */
} else if (strncmp(args, "db=", 3) == 0) {
const char *db;
args = strip(args+3);
if (*args != '"') {
continue;
}
args++;
db = args;
args = strpbrk(args, "\"\n");
opts->nss_db = g_strndup(db, args-db);
if (*args != 0) {
args++;
}
} else {
args = find_blank(args);
}
} while (*args != 0);
void multi_options_read_config()
{
CFILE *in;
char str[512];
char *tok = NULL;
// set default value for the global multi options
Multi_options_g.reset();
ushort forced_port = (ushort)os_config_read_uint(NULL, "ForcePort", 0);
Multi_options_g.port = (Cmdline_network_port >= 0) ? (ushort)Cmdline_network_port : forced_port == 0 ? (ushort)DEFAULT_GAME_PORT : forced_port;
Multi_options_g.log = (Cmdline_multi_log) ? 1 : 0;
// read in the config file
in = cfopen(MULTI_CFG_FILE, "rt", CFILE_NORMAL, CF_TYPE_DATA);
// if we failed to open the config file, user default settings
if (in == NULL) {
nprintf(("Network","Failed to open network config file, using default settings\n"));
} else {
while ( !cfeof(in) ) {
// read in the game info
memset(str, 0, 512);
cfgets(str, 512, in);
// parse the first line
tok = strtok(str, " \t");
// check the token
if (tok != NULL) {
drop_leading_white_space(tok);
drop_trailing_white_space(tok);
} else {
continue;
}
// all possible options
// only standalone cares about the following options
if (Is_standalone) {
// setup PXO mode
if ( SETTING("+pxo") ) {
NEXT_TOKEN();
if (tok != NULL) {
strncpy(Multi_fs_tracker_channel, tok, MAX_PATH-1);
}
} else
// set the standalone server's permanent name
if ( SETTING("+name") ) {
NEXT_TOKEN();
if (tok != NULL) {
strncpy(Multi_options_g.std_pname, tok, STD_NAME_LEN);
}
} else
// standalone won't allow voice transmission
if ( SETTING("+no_voice") ) {
Multi_options_g.std_voice = 0;
} else
// set the max # of players on the standalone
if ( SETTING("+max_players") ) {
NEXT_TOKEN();
if (tok != NULL) {
if ( !((atoi(tok) < 1) || (atoi(tok) > MAX_PLAYERS)) ) {
Multi_options_g.std_max_players = atoi(tok);
}
}
} else
// ban a player
if ( SETTING("+ban") ) {
NEXT_TOKEN();
if (tok != NULL) {
std_add_ban(tok);
}
} else
// set the standalone host password
if ( SETTING("+passwd") ) {
NEXT_TOKEN();
if (tok != NULL) {
strncpy(Multi_options_g.std_passwd, tok, STD_PASSWD_LEN);
#ifdef _WIN32
// yuck
extern HWND Multi_std_host_passwd;
SetWindowText(Multi_std_host_passwd, Multi_options_g.std_passwd);
#else
// TODO: get password ?
// argh, gonna have to figure out how to do this - mharris 07/07/2002
#endif
}
} else
// set standalone to low updates
if ( SETTING("+low_update") ) {
Multi_options_g.std_datarate = OBJ_UPDATE_LOW;
} else
// set standalone to medium updates
if ( SETTING("+med_update") ) {
Multi_options_g.std_datarate = OBJ_UPDATE_MEDIUM;
} else
// set standalone to high updates
if ( SETTING("+high_update") ) {
Multi_options_g.std_datarate = OBJ_UPDATE_HIGH;
} else
// set standalone to high updates
if ( SETTING("+lan_update") ) {
Multi_options_g.std_datarate = OBJ_UPDATE_LAN;
} else
// use pxo flag
if ( SETTING("+use_pxo") ) {
Om_tracker_flag = 1;
} else
// standalone pxo login user
if ( SETTING("+pxo_login") ) {
NEXT_TOKEN();
if (tok != NULL) {
strncpy(Multi_options_g.std_pxo_login, tok, MULTI_TRACKER_STRING_LEN);
}
} else
// standalone pxo login password
if ( SETTING("+pxo_password") ) {
NEXT_TOKEN();
if (tok != NULL) {
strncpy(Multi_options_g.std_pxo_password, tok, MULTI_TRACKER_STRING_LEN);
}
} else
if ( SETTING("+webui_root") ) {
NEXT_TOKEN();
if (tok != NULL) {
Multi_options_g.webuiRootDirectory = SCP_string(tok);
}
} else
if ( SETTING("+webapi_username") ) {
NEXT_TOKEN();
if (tok != NULL) {
Multi_options_g.webapiUsername = SCP_string(tok);
}
} else
if ( SETTING("+webapi_password") ) {
NEXT_TOKEN();
if (tok != NULL) {
Multi_options_g.webapiPassword = SCP_string(tok);
}
} else
if ( SETTING("+webapi_server_port") ) {
NEXT_TOKEN();
if (tok != NULL) {
long int result = strtol(tok, NULL, 10);
if(result <= 0 || result > USHRT_MAX) {
mprintf(("ERROR: Invalid or out of range webapi_server_port '%s' specified in multi.cfg, must be integer between 1024 and %i.\n", tok, USHRT_MAX));
}
else if(result < 1024) {
mprintf(("ERROR: webapi_server_port '%ld' in multi.cfg is too low, must be between 1024 and %d.\n", result, USHRT_MAX));
}
else {
mprintf(("Using webapi_server_port '%ld' from multi.cfg.\n", result));
Multi_options_g.webapiPort = (ushort) result;
}
}
}
}
// ... common to all modes ...
// ip addr of user tracker
if ( SETTING("+user_server") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.user_tracker_ip, tok);
}
} else
// ip addr of game tracker
if ( SETTING("+game_server") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.game_tracker_ip, tok);
}
} else
// port to use for the game/user tracker (FS2NetD)
if ( SETTING("+server_port") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.tracker_port, tok);
}
} else
// ip addr of pxo chat server
if ( SETTING("+chat_server") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.pxo_ip, tok);
}
} else
// url of pilot rankings page
if ( SETTING("+rank_url") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.pxo_rank_url, tok);
}
} else
// url of pxo account create page
if ( SETTING("+create_url") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.pxo_create_url, tok);
}
} else
// url of pxo account verify page
if ( SETTING("+verify_url") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.pxo_verify_url, tok);
}
} else
// url of pxo banners
if ( SETTING("+banner_url") ) {
NEXT_TOKEN();
if (tok != NULL) {
strcpy_s(Multi_options_g.pxo_banner_url, tok);
}
} else
// set the max datarate for high updates
if ( SETTING("+datarate") ) {
NEXT_TOKEN();
if (tok != NULL) {
if ( atoi(tok) >= 4000 ) {
Multi_options_g.datarate_cap = atoi(tok);
}
}
} else
// get the proxy server
if ( SETTING("+http_proxy") ) {
NEXT_TOKEN();
if (tok != NULL) {
char *ip = strtok(tok, ":");
if (ip != NULL) {
strcpy_s(Multi_options_proxy, ip);
}
ip = strtok(NULL, "");
if (ip != NULL) {
Multi_options_proxy_port = (ushort)atoi(ip);
} else {
strcpy_s(Multi_options_proxy, "");
}
}
}
}
// close the config file
cfclose(in);
in = NULL;
}
#ifndef _WIN32
if (Is_standalone) {
std_configLoaded(&Multi_options_g);
}
#endif
}
