/**
* Get the update file and parse it
* p_update has to be locked when calling this function
*
* \param p_update pointer to update struct
* \return true if the update is valid and authenticated
*/
static bool GetUpdateFile( update_t *p_update )
{
stream_t *p_stream = NULL;
int i_major = 0;
int i_minor = 0;
int i_revision = 0;
unsigned char extra;
char *psz_version_line = NULL;
char *psz_update_data = NULL;
p_stream = stream_UrlNew( p_update->p_libvlc, UPDATE_VLC_STATUS_URL );
if( !p_stream )
{
msg_Err( p_update->p_libvlc, "Failed to open %s for reading",
UPDATE_VLC_STATUS_URL );
goto error;
}
const int64_t i_read = stream_Size( p_stream );
psz_update_data = malloc( i_read + 1 ); /* terminating '\0' */
if( !psz_update_data )
goto error;
if( stream_Read( p_stream, psz_update_data, i_read ) != i_read )
{
msg_Err( p_update->p_libvlc, "Couldn't download update file %s",
UPDATE_VLC_STATUS_URL );
goto error;
}
psz_update_data[i_read] = '\0';
stream_Delete( p_stream );
p_stream = NULL;
/* first line : version number */
char *psz_update_data_parser = psz_update_data;
size_t i_len = strcspn( psz_update_data, "\r\n" );
psz_update_data_parser += i_len;
while( *psz_update_data_parser == '\r' || *psz_update_data_parser == '\n' )
psz_update_data_parser++;
if( !(psz_version_line = malloc( i_len + 1)) )
goto error;
strncpy( psz_version_line, psz_update_data, i_len );
psz_version_line[i_len] = '\0';
p_update->release.extra = 0;
switch( sscanf( psz_version_line, "%i.%i.%i%c",
&i_major, &i_minor, &i_revision, &extra ) )
{
case 4:
p_update->release.extra = extra;
case 3:
p_update->release.i_major = i_major;
p_update->release.i_minor = i_minor;
p_update->release.i_revision = i_revision;
break;
default:
msg_Err( p_update->p_libvlc, "Update version false formated" );
goto error;
}
/* second line : URL */
i_len = strcspn( psz_update_data_parser, "\r\n" );
if( i_len == 0 )
{
msg_Err( p_update->p_libvlc, "Update file %s is corrupted: URL missing",
UPDATE_VLC_STATUS_URL );
goto error;
}
if( !(p_update->release.psz_url = malloc( i_len + 1)) )
goto error;
strncpy( p_update->release.psz_url, psz_update_data_parser, i_len );
p_update->release.psz_url[i_len] = '\0';
psz_update_data_parser += i_len;
while( *psz_update_data_parser == '\r' || *psz_update_data_parser == '\n' )
psz_update_data_parser++;
/* Remaining data : description */
i_len = strlen( psz_update_data_parser );
if( i_len == 0 )
{
msg_Err( p_update->p_libvlc,
"Update file %s is corrupted: description missing",
UPDATE_VLC_STATUS_URL );
goto error;
}
if( !(p_update->release.psz_desc = malloc( i_len + 1)) )
goto error;
strncpy( p_update->release.psz_desc, psz_update_data_parser, i_len );
p_update->release.psz_desc[i_len] = '\0';
/* Now that we know the status is valid, we must download its signature
* to authenticate it */
signature_packet_t sign;
if( download_signature( VLC_OBJECT( p_update->p_libvlc ), &sign,
UPDATE_VLC_STATUS_URL ) != VLC_SUCCESS )
{
msg_Err( p_update->p_libvlc, "Couldn't download signature of status file" );
goto error;
}
if( sign.type != BINARY_SIGNATURE && sign.type != TEXT_SIGNATURE )
{
msg_Err( p_update->p_libvlc, "Invalid signature type" );
goto error;
}
p_update->p_pkey = (public_key_t*)malloc( sizeof( public_key_t ) );
if( !p_update->p_pkey )
goto error;
if( parse_public_key( videolan_public_key, sizeof( videolan_public_key ),
p_update->p_pkey, NULL ) != VLC_SUCCESS )
{
msg_Err( p_update->p_libvlc, "Couldn't parse embedded public key, something went really wrong..." );
FREENULL( p_update->p_pkey );
goto error;
}
memcpy( p_update->p_pkey->longid, videolan_public_key_longid, 8 );
if( memcmp( sign.issuer_longid, p_update->p_pkey->longid , 8 ) != 0 )
{
msg_Dbg( p_update->p_libvlc, "Need to download the GPG key" );
public_key_t *p_new_pkey = download_key(
VLC_OBJECT(p_update->p_libvlc),
sign.issuer_longid, videolan_public_key_longid );
if( !p_new_pkey )
{
msg_Err( p_update->p_libvlc, "Couldn't download GPG key" );
FREENULL( p_update->p_pkey );
goto error;
}
uint8_t *p_hash = hash_sha1_from_public_key( p_new_pkey );
if( !p_hash )
{
msg_Err( p_update->p_libvlc, "Failed to hash signature" );
free( p_new_pkey );
FREENULL( p_update->p_pkey );
goto error;
}
if( verify_signature( p_new_pkey->sig.r, p_new_pkey->sig.s,
&p_update->p_pkey->key, p_hash ) == VLC_SUCCESS )
{
free( p_hash );
msg_Info( p_update->p_libvlc, "Key authenticated" );
free( p_update->p_pkey );
p_update->p_pkey = p_new_pkey;
}
else
{
free( p_hash );
msg_Err( p_update->p_libvlc, "Key signature invalid !\n" );
goto error;
}
}
uint8_t *p_hash = hash_sha1_from_text( psz_update_data, &sign );
if( !p_hash )
{
msg_Warn( p_update->p_libvlc, "Can't compute SHA1 hash for status file" );
goto error;
}
else if( p_hash[0] != sign.hash_verification[0] ||
p_hash[1] != sign.hash_verification[1] )
{
msg_Warn( p_update->p_libvlc, "Bad SHA1 hash for status file" );
goto error;
}
else if( verify_signature( sign.r, sign.s, &p_update->p_pkey->key, p_hash )
!= VLC_SUCCESS )
{
msg_Err( p_update->p_libvlc, "BAD SIGNATURE for status file" );
goto error;
}
else
{
msg_Info( p_update->p_libvlc, "Status file authenticated" );
return true;
}
error:
if( p_stream )
stream_Delete( p_stream );
free( psz_version_line );
free( psz_update_data );
return false;
}
int
main(int argc, char **argv)
{
krb5_context context;
krb5_principal princ;
krb5_salt salt;
int optidx;
char buf[1024];
krb5_enctype etype;
krb5_error_code ret;
optidx = krb5_program_setup(&context, argc, argv, args, num_args, NULL);
if(help)
usage(0);
if(version){
print_version (NULL);
return 0;
}
argc -= optidx;
argv += optidx;
if (argc > 1)
usage(1);
if(!version5 && !version4 && !afs)
version5 = 1;
ret = krb5_string_to_enctype(context, keytype_str, &etype);
if(ret)
krb5_err(context, 1, ret, "krb5_string_to_enctype");
if((etype != (krb5_enctype)ETYPE_DES_CBC_CRC &&
etype != (krb5_enctype)ETYPE_DES_CBC_MD4 &&
etype != (krb5_enctype)ETYPE_DES_CBC_MD5) &&
(afs || version4)) {
if(!version5) {
etype = ETYPE_DES_CBC_CRC;
} else {
krb5_errx(context, 1,
"DES is the only valid keytype for AFS and Kerberos 4");
}
}
if(version5 && principal == NULL){
printf("Kerberos v5 principal: ");
if(fgets(buf, sizeof(buf), stdin) == NULL)
return 1;
buf[strcspn(buf, "\r\n")] = '\0';
principal = estrdup(buf);
}
if(afs && cell == NULL){
printf("AFS cell: ");
if(fgets(buf, sizeof(buf), stdin) == NULL)
return 1;
buf[strcspn(buf, "\r\n")] = '\0';
cell = estrdup(buf);
}
if(argv[0])
password = argv[0];
if(password == NULL){
if(UI_UTIL_read_pw_string(buf, sizeof(buf), "Password: "******"failed to unparse name: %s", principal);
ret = krb5_get_pw_salt(context, princ, &salt);
if (ret)
krb5_err(context, 1, ret, "failed to get salt for %s", principal);
tokey(context, etype, password, salt, "Kerberos 5 (%s)");
krb5_free_salt(context, salt);
}
if(version4){
salt.salttype = KRB5_PW_SALT;
salt.saltvalue.length = 0;
salt.saltvalue.data = NULL;
tokey(context, ETYPE_DES_CBC_MD5, password, salt, "Kerberos 4");
}
if(afs){
salt.salttype = KRB5_AFS3_SALT;
salt.saltvalue.length = strlen(cell);
salt.saltvalue.data = cell;
tokey(context, ETYPE_DES_CBC_MD5, password, salt, "AFS");
}
return 0;
}
int
main(int argc, char **argv)
{
char *path, *label, **var, tmp[PATH_MAX];
const char *s;
int opt, flags, keys;
#if defined(DEBUG) && defined(__OpenBSD__)
malloc_options = (char *) "AFGJPX";
#endif
setlocale(LC_TIME, "");
tzset();
if (**argv == '-')
flags = CLIENT_LOGIN;
else
flags = 0;
label = path = NULL;
while ((opt = getopt(argc, argv, "2c:Cdf:lL:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= CLIENT_256COLOURS;
break;
case 'c':
free(shell_cmd);
shell_cmd = xstrdup(optarg);
break;
case 'C':
if (flags & CLIENT_CONTROL)
flags |= CLIENT_CONTROLCONTROL;
else
flags |= CLIENT_CONTROL;
break;
case 'V':
printf("%s %s\n", __progname, VERSION);
exit(0);
case 'f':
set_cfg_file(optarg);
break;
case 'l':
flags |= CLIENT_LOGIN;
break;
case 'L':
free(label);
label = xstrdup(optarg);
break;
case 'q':
break;
case 'S':
free(path);
path = xstrdup(optarg);
break;
case 'u':
flags |= CLIENT_UTF8;
break;
case 'v':
debug_level++;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (shell_cmd != NULL && argc != 0)
usage();
#ifdef __OpenBSD__
if (pledge("stdio rpath wpath cpath flock fattr unix sendfd recvfd "
"proc exec tty ps", NULL) != 0)
err(1, "pledge");
#endif
/*
* tmux is a UTF-8 terminal, so if TMUX is set, assume UTF-8.
* Otherwise, if the user has set LC_ALL, LC_CTYPE or LANG to contain
* UTF-8, it is a safe assumption that either they are using a UTF-8
* terminal, or if not they know that output from UTF-8-capable
* programs may be wrong.
*/
if (getenv("TMUX") != NULL)
flags |= CLIENT_UTF8;
else {
s = getenv("LC_ALL");
if (s == NULL || *s == '\0')
s = getenv("LC_CTYPE");
if (s == NULL || *s == '\0')
s = getenv("LANG");
if (s == NULL || *s == '\0')
s = "";
if (strcasestr(s, "UTF-8") != NULL ||
strcasestr(s, "UTF8") != NULL)
flags |= CLIENT_UTF8;
}
global_environ = environ_create();
for (var = environ; *var != NULL; var++)
environ_put(global_environ, *var);
if (getcwd(tmp, sizeof tmp) != NULL)
environ_set(global_environ, "PWD", tmp);
global_options = options_create(NULL);
options_table_populate_tree(server_options_table, global_options);
global_s_options = options_create(NULL);
options_table_populate_tree(session_options_table, global_s_options);
options_set_string(global_s_options, "default-shell", "%s", getshell());
global_w_options = options_create(NULL);
options_table_populate_tree(window_options_table, global_w_options);
/* Override keys to vi if VISUAL or EDITOR are set. */
if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
if (strrchr(s, '/') != NULL)
s = strrchr(s, '/') + 1;
if (strstr(s, "vi") != NULL)
keys = MODEKEY_VI;
else
keys = MODEKEY_EMACS;
options_set_number(global_s_options, "status-keys", keys);
options_set_number(global_w_options, "mode-keys", keys);
}
/*
* Figure out the socket path. If specified on the command-line with -S
* or -L, use it, otherwise try $TMUX or assume -L default.
*/
if (path == NULL) {
/* If no -L, use the environment. */
if (label == NULL) {
s = getenv("TMUX");
if (s != NULL) {
path = xstrdup(s);
path[strcspn (path, ",")] = '\0';
if (*path == '\0') {
free(path);
label = xstrdup("default");
}
} else
label = xstrdup("default");
}
/* -L or default set. */
if (label != NULL) {
if ((path = makesocketpath(label)) == NULL) {
fprintf(stderr, "can't create socket: %s\n",
strerror(errno));
exit(1);
}
}
}
free(label);
if (strlcpy(socket_path, path, sizeof socket_path) >=
sizeof socket_path) {
fprintf(stderr, "socket path too long: %s\n", path);
exit(1);
}
free(path);
/* Pass control to the client. */
exit(client_main(osdep_event_init(), argc, argv, flags));
}
char *yahoo_crypt(char *key, char *salt)
{
char *buffer = NULL;
int buflen = 0;
int needed = 3 + strlen(salt) + 1 + 26 + 1;
md5_byte_t alt_result[16];
md5_state_t ctx;
md5_state_t alt_ctx;
size_t salt_len;
size_t key_len;
size_t cnt;
char *cp;
if (buflen < needed) {
buflen = needed;
if ((buffer = realloc(buffer, buflen)) == NULL)
return NULL;
}
/* Find beginning of salt string. The prefix should normally always
be present. Just in case it is not. */
if (strncmp(md5_salt_prefix, salt, sizeof(md5_salt_prefix) - 1) == 0)
/* Skip salt prefix. */
salt += sizeof(md5_salt_prefix) - 1;
salt_len = MIN(strcspn(salt, "$"), 8);
key_len = strlen(key);
/* Prepare for the real work. */
md5_init(&ctx);
/* Add the key string. */
md5_append(&ctx, (md5_byte_t *)key, key_len);
/* Because the SALT argument need not always have the salt prefix we
add it separately. */
md5_append(&ctx, (md5_byte_t *)md5_salt_prefix,
sizeof(md5_salt_prefix) - 1);
/* The last part is the salt string. This must be at most 8
characters and it ends at the first `$' character (for
compatibility which existing solutions). */
md5_append(&ctx, (md5_byte_t *)salt, salt_len);
/* Compute alternate MD5 sum with input KEY, SALT, and KEY. The
final result will be added to the first context. */
md5_init(&alt_ctx);
/* Add key. */
md5_append(&alt_ctx, (md5_byte_t *)key, key_len);
/* Add salt. */
md5_append(&alt_ctx, (md5_byte_t *)salt, salt_len);
/* Add key again. */
md5_append(&alt_ctx, (md5_byte_t *)key, key_len);
/* Now get result of this (16 bytes) and add it to the other
context. */
md5_finish(&alt_ctx, alt_result);
/* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 16; cnt -= 16)
md5_append(&ctx, alt_result, 16);
md5_append(&ctx, alt_result, cnt);
/* For the following code we need a NUL byte. */
alt_result[0] = '\0';
/* The original implementation now does something weird: for every 1
bit in the key the first 0 is added to the buffer, for every 0
bit the first character of the key. This does not seem to be
what was intended but we have to follow this to be compatible. */
for (cnt = key_len; cnt > 0; cnt >>= 1)
md5_append(&ctx,
(cnt & 1) != 0 ? alt_result : (md5_byte_t *)key, 1);
/* Create intermediate result. */
md5_finish(&ctx, alt_result);
/* Now comes another weirdness. In fear of password crackers here
comes a quite long loop which just processes the output of the
previous round again. We cannot ignore this here. */
for (cnt = 0; cnt < 1000; ++cnt) {
/* New context. */
md5_init(&ctx);
/* Add key or last result. */
if ((cnt & 1) != 0)
md5_append(&ctx, (md5_byte_t *)key, key_len);
else
md5_append(&ctx, alt_result, 16);
/* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0)
md5_append(&ctx, (md5_byte_t *)salt, salt_len);
/* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0)
md5_append(&ctx, (md5_byte_t *)key, key_len);
/* Add key or last result. */
if ((cnt & 1) != 0)
md5_append(&ctx, alt_result, 16);
else
md5_append(&ctx, (md5_byte_t *)key, key_len);
/* Create intermediate result. */
md5_finish(&ctx, alt_result);
}
/* Now we can construct the result string. It consists of three
parts. */
strncpy(buffer, md5_salt_prefix, MAX(0, buflen));
cp = buffer + strlen(buffer);
buflen -= sizeof(md5_salt_prefix);
strncpy(cp, salt, MIN((size_t) buflen, salt_len));
cp = cp + strlen(cp);
buflen -= MIN((size_t) buflen, salt_len);
if (buflen > 0) {
*cp++ = '$';
--buflen;
}
#define b64_from_24bit(B2, B1, B0, N) \
do { \
unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \
int n = (N); \
while (n-- > 0 && buflen > 0) { \
*cp++ = b64t[w & 0x3f]; \
--buflen; \
w >>= 6; \
}\
} while (0)
b64_from_24bit(alt_result[0], alt_result[6], alt_result[12], 4);
b64_from_24bit(alt_result[1], alt_result[7], alt_result[13], 4);
b64_from_24bit(alt_result[2], alt_result[8], alt_result[14], 4);
b64_from_24bit(alt_result[3], alt_result[9], alt_result[15], 4);
b64_from_24bit(alt_result[4], alt_result[10], alt_result[5], 4);
b64_from_24bit(0, 0, alt_result[11], 2);
if (buflen <= 0) {
FREE(buffer);
} else
*cp = '\0'; /* Terminate the string. */
/* Clear the buffer for the intermediate result so that people
attaching to processes or reading core dumps cannot get any
information. We do it in this way to clear correct_words[]
inside the MD5 implementation as well. */
md5_init(&ctx);
md5_finish(&ctx, alt_result);
memset(&ctx, '\0', sizeof(ctx));
memset(&alt_ctx, '\0', sizeof(alt_ctx));
return buffer;
}
static int
parse_unix(direntry *de, char *line)
{
char *p, *q;
if (strncmp(line, "total ", 6) == 0)
return 1;
if (strcspn(line, " ") < 10
|| (line[10]!=' ' && !isdigit(line[10])))
return -1;
if ((de->line=(char *)malloc(strlen(line)+2)) == NULL)
return 1;
de->line[0] = ' ';
strcpy(de->line+1, line);
switch (line[0]) {
case 'l':
case 'd':
de->type = line[0];
break;
case '-':
case 'p':
de->type = 'f';
break;
default:
de->type = 'x';
}
strtok(line+10, " "); /* skip perms, links */
strtok(NULL, " "); /* owner */
strtok(NULL, " "); /* group */
if ((p=strtok(NULL, " ")) == NULL) {
free(line);
return 1;
}
de->size = strtoll(p, &q, 10);
/* size */
if (p == q)
de->size = -1;
else if ((p=strtok(NULL, " ")) == NULL) {
free(line);
return 1;
}
p[12] = '\0';
de->mtime = parse_time(p);
p += 13;
if (de->type == 'l') {
q = p + strlen(p) - de->size;
if (strncmp(q-4, " -> ", 4) == 0) {
q[-4] = '\0';
de->name = strdup(p);
de->link = strdup(q);
}
else {
if ((q=strstr(p, " -> ")) == NULL) {
/* unknown link format */
de->name = strdup(p);
de->link = NULL;
}
else {
*q = '\0';
de->name = strdup(p);
de->link = strdup(q+4);
}
}
de->size = -1;
}
else {
de->name = strdup(p);
de->link = NULL;
}
if (de->type == 'd' && (strcmp(de->name, "..")==0 ||
strcmp(de->name, ".")==0)) {
free(de->name);
return 1;
}
return 0;
}
struct uct_dynkomi *
uct_dynkomi_init_linear(struct uct *u, char *arg, struct board *b)
{
struct uct_dynkomi *d = calloc2(1, sizeof(*d));
d->uct = u;
d->permove = linear_permove;
d->persim = linear_persim;
d->done = generic_done;
struct dynkomi_linear *l = calloc2(1, sizeof(*l));
d->data = l;
/* Force white to feel behind and try harder, but not to the
* point of resigning immediately in high handicap games.
* By move 100 white should still be behind but should have
* caught up enough to avoid resigning. */
int moves = board_large(b) ? 100 : 50;
if (!board_small(b)) {
l->moves[S_BLACK] = moves;
l->moves[S_WHITE] = moves;
}
/* The real value of one stone is twice the komi so about 15 points.
* But use a lower value to avoid being too pessimistic as black
* or too optimistic as white. */
l->handicap_value[S_BLACK] = 8;
l->handicap_value[S_WHITE] = 1;
l->komi_ratchet = INFINITY;
l->green_zone = 0.85;
l->orange_zone = 0.8;
l->drop_step = 4.0;
if (arg) {
char *optspec, *next = arg;
while (*next) {
optspec = next;
next += strcspn(next, ":");
if (*next) { *next++ = 0; } else { *next = 0; }
char *optname = optspec;
char *optval = strchr(optspec, '=');
if (optval) *optval++ = 0;
if (!strcasecmp(optname, "moves") && optval) {
/* Dynamic komi in handicap game; linearly
* decreases to basic settings until move
* #optval. moves=blackmoves%whitemoves */
for (int i = S_BLACK; *optval && i <= S_WHITE; i++) {
l->moves[i] = atoi(optval);
optval += strcspn(optval, "%");
if (*optval) optval++;
}
} else if (!strcasecmp(optname, "handicap_value") && optval) {
/* Point value of single handicap stone,
* for dynkomi computation. */
for (int i = S_BLACK; *optval && i <= S_WHITE; i++) {
l->handicap_value[i] = atoi(optval);
optval += strcspn(optval, "%");
if (*optval) optval++;
}
} else if (!strcasecmp(optname, "rootbased")) {
/* If set, the extra komi applied will be
* the same for all simulations within a move,
* instead of being same for all simulations
* within the tree node. */
l->rootbased = !optval || atoi(optval);
} else if (!strcasecmp(optname, "green_zone") && optval) {
/* Increase komi when win ratio is above green_zone */
l->green_zone = atof(optval);
} else if (!strcasecmp(optname, "orange_zone") && optval) {
/* Decrease komi when > 0 and win ratio is below orange_zone */
l->orange_zone = atof(optval);
} else if (!strcasecmp(optname, "drop_step") && optval) {
/* Decrease komi by drop_step points */
l->drop_step = atof(optval);
} else {
fprintf(stderr, "uct: Invalid dynkomi argument %s or missing value\n", optname);
exit(1);
}
}
}
return d;
}
static bool
Send_Message(CLIENT * Client, REQUEST * Req, int ForceType, bool SendErrors)
{
CLIENT *cl, *from;
CL2CHAN *cl2chan;
CHANNEL *chan;
char *currentTarget = Req->argv[0];
char *lastCurrentTarget = NULL;
char *message = NULL;
assert(Client != NULL);
assert(Req != NULL);
if (Req->argc == 0) {
if (!SendErrors)
return CONNECTED;
return IRC_WriteStrClient(Client, ERR_NORECIPIENT_MSG,
Client_ID(Client), Req->command);
}
if (Req->argc == 1) {
if (!SendErrors)
return CONNECTED;
return IRC_WriteStrClient(Client, ERR_NOTEXTTOSEND_MSG,
Client_ID(Client));
}
if (Req->argc > 2) {
if (!SendErrors)
return CONNECTED;
return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
Client_ID(Client), Req->command);
}
if (Client_Type(Client) == CLIENT_SERVER)
from = Client_Search(Req->prefix);
else
from = Client;
if (!from)
return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
Client_ID(Client), Req->prefix);
#ifdef ICONV
if (Client_Conn(Client) > NONE)
message = Conn_EncodingFrom(Client_Conn(Client), Req->argv[1]);
else
#endif
message = Req->argv[1];
/* handle msgtarget = msgto *("," msgto) */
currentTarget = strtok_r(currentTarget, ",", &lastCurrentTarget);
ngt_UpperStr(Req->command);
while (currentTarget) {
/* Check for and handle valid <msgto> of form:
* RFC 2812 2.3.1:
* msgto = channel / ( user [ "%" host ] "@" servername )
* msgto =/ ( user "%" host ) / targetmask
* msgto =/ nickname / ( nickname "!" user "@" host )
*/
if (strchr(currentTarget, '!') == NULL)
/* nickname */
cl = Client_Search(currentTarget);
else
cl = NULL;
if (cl == NULL) {
/* If currentTarget isn't a nickname check for:
* user ["%" host] "@" servername
* user "%" host
* nickname "!" user "@" host
*/
char target[COMMAND_LEN];
char * nick = NULL;
char * user = NULL;
char * host = NULL;
char * server = NULL;
strlcpy(target, currentTarget, COMMAND_LEN);
server = strchr(target, '@');
if (server) {
*server = '\0';
server++;
}
host = strchr(target, '%');
if (host) {
*host = '\0';
host++;
}
user = strchr(target, '!');
if (user) {
/* msgto form: nick!user@host */
*user = '******';
user++;
nick = target;
host = server; /* not "@server" but "@host" */
} else {
user = target;
}
for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
if (Client_Type(cl) != CLIENT_USER &&
Client_Type(cl) != CLIENT_SERVICE)
continue;
if (nick != NULL && host != NULL) {
if (strcasecmp(nick, Client_ID(cl)) == 0 &&
strcasecmp(user, Client_User(cl)) == 0 &&
strcasecmp(host, Client_HostnameCloaked(cl)) == 0)
break;
else
continue;
}
if (strcasecmp(user, Client_User(cl)) != 0)
continue;
if (host != NULL && strcasecmp(host,
Client_HostnameCloaked(cl)) != 0)
continue;
if (server != NULL && strcasecmp(server,
Client_ID(Client_Introducer(cl))) != 0)
continue;
break;
}
}
if (cl) {
/* Target is a user, enforce type */
#ifndef STRICT_RFC
if (Client_Type(cl) != ForceType &&
!(ForceType == CLIENT_USER &&
(Client_Type(cl) == CLIENT_USER ||
Client_Type(cl) == CLIENT_SERVICE))) {
#else
if (Client_Type(cl) != ForceType) {
#endif
if (SendErrors && !IRC_WriteStrClient(
from, ERR_NOSUCHNICK_MSG,Client_ID(from),
currentTarget))
return DISCONNECTED;
goto send_next_target;
}
#ifndef STRICT_RFC
if (ForceType == CLIENT_SERVICE &&
(Conn_Options(Client_Conn(Client_NextHop(cl)))
& CONN_RFC1459)) {
/* SQUERY command but RFC 1459 link: convert
* request to PRIVMSG command */
Req->command = "PRIVMSG";
}
#endif
if (Client_HasMode(cl, 'b') &&
!Client_HasMode(from, 'R') &&
!Client_HasMode(from, 'o') &&
!(Client_Type(from) == CLIENT_SERVER) &&
!(Client_Type(from) == CLIENT_SERVICE)) {
if (SendErrors && !IRC_WriteStrClient(from,
ERR_NONONREG_MSG,
Client_ID(from), Client_ID(cl)))
return DISCONNECTED;
goto send_next_target;
}
if (Client_HasMode(cl, 'C')) {
cl2chan = Channel_FirstChannelOf(cl);
while (cl2chan) {
chan = Channel_GetChannel(cl2chan);
if (Channel_IsMemberOf(chan, from))
break;
cl2chan = Channel_NextChannelOf(cl, cl2chan);
}
if (!cl2chan) {
if (SendErrors && !IRC_WriteStrClient(
from, ERR_NOTONSAMECHANNEL_MSG,
Client_ID(from), Client_ID(cl)))
return DISCONNECTED;
goto send_next_target;
}
}
if (SendErrors && (Client_Type(Client) != CLIENT_SERVER)
&& strchr(Client_Modes(cl), 'a')) {
/* Target is away */
if (!IRC_WriteStrClient(from, RPL_AWAY_MSG,
Client_ID(from),
Client_ID(cl),
Client_Away(cl)))
return DISCONNECTED;
}
if (Client_Conn(from) > NONE) {
Conn_UpdateIdle(Client_Conn(from));
}
if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
Req->command, Client_ID(cl),
message))
return DISCONNECTED;
} else if (ForceType != CLIENT_SERVICE
&& (chan = Channel_Search(currentTarget))) {
if (!Channel_Write(chan, from, Client, Req->command,
SendErrors, message))
return DISCONNECTED;
} else if (ForceType != CLIENT_SERVICE
/* $#: server/target mask, RFC 2812, sec. 3.3.1 */
&& strchr("$#", currentTarget[0])
&& strchr(currentTarget, '.')) {
/* targetmask */
if (!Send_Message_Mask(from, Req->command, currentTarget,
message, SendErrors))
return DISCONNECTED;
} else {
if (!SendErrors)
return CONNECTED;
if (!IRC_WriteStrClient(from, ERR_NOSUCHNICK_MSG,
Client_ID(from), currentTarget))
return DISCONNECTED;
}
send_next_target:
currentTarget = strtok_r(NULL, ",", &lastCurrentTarget);
if (currentTarget)
Conn_SetPenalty(Client_Conn(Client), 1);
}
return CONNECTED;
} /* Send_Message */
static bool
Send_Message_Mask(CLIENT * from, char * command, char * targetMask,
char * message, bool SendErrors)
{
CLIENT *cl;
bool client_match;
char *mask = targetMask + 1;
const char *check_wildcards;
cl = NULL;
if (strchr(Client_Modes(from), 'o') == NULL) {
if (!SendErrors)
return true;
return IRC_WriteStrClient(from, ERR_NOPRIVILEGES_MSG,
Client_ID(from));
}
/*
* RFC 2812, sec. 3.3.1 requires that targetMask have at least one
* dot (".") and no wildcards ("*", "?") following the last one.
*/
check_wildcards = strrchr(targetMask, '.');
assert(check_wildcards != NULL);
if (check_wildcards &&
check_wildcards[strcspn(check_wildcards, "*?")])
{
if (!SendErrors)
return true;
return IRC_WriteStrClient(from, ERR_WILDTOPLEVEL, targetMask);
}
/* #: hostmask, see RFC 2812, sec. 3.3.1 */
if (targetMask[0] == '#') {
for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
if (Client_Type(cl) != CLIENT_USER)
continue;
client_match = MatchCaseInsensitive(mask, Client_Hostname(cl));
if (client_match)
if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
command, Client_ID(cl), message))
return false;
}
} else {
assert(targetMask[0] == '$'); /* $: server mask, see RFC 2812, sec. 3.3.1 */
for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
if (Client_Type(cl) != CLIENT_USER)
continue;
client_match = MatchCaseInsensitive(mask,
Client_ID(Client_Introducer(cl)));
if (client_match)
if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
command, Client_ID(cl), message))
return false;
}
}
return CONNECTED;
} /* Send_Message_Mask */
/*
* parseline - Parse the command line and build the argv array.
*
* Parameters:
* cmdline: The command line, in the form:
*
* command [arguments...] [< infile] [> oufile] [&]
*
* tok: Pointer to a cmdline_tokens structure. The elements of this
* structure will be populated with the parsed tokens. Characters
* enclosed in single or double quotes are treated as a single
* argument.
* Returns:
* 1: if the user has requested a BG job
* 0: if the user has requested a FG job
* -1: if cmdline is incorrectly formatted
*
* Note: The string elements of tok (e.g., argv[], infile, outfile)
* are statically allocated inside parseline() and will be
* overwritten the next time this function is invoked.
*/
int parseline(const char *cmdline, struct cmdline_tokens *tok)
{
static char array[MAXLINE]; /* holds local copy of command line */
const char delims[10] = " \t\r\n"; /* argument delimiters (white-space) */
char *buf = array; /* ptr that traverses command line */
char *next; /* ptr to the end of the current arg */
char *endbuf; /* ptr to end of cmdline string */
int is_bg; /* background job? */
int parsing_state; /* indicates if the next token is the
input or output file */
if (cmdline == NULL) {
(void) fprintf(stderr, "Error: command line is NULL\n");
return -1;
}
(void) strncpy(buf, cmdline, MAXLINE);
endbuf = buf + strlen(buf);
tok->infile = NULL;
tok->outfile = NULL;
/* Build the argv list */
parsing_state = ST_NORMAL;
tok->argc = 0;
while (buf < endbuf) {
/* Skip the white-spaces */
buf += strspn (buf, delims);
if (buf >= endbuf) break;
/* Check for I/O redirection specifiers */
if (*buf == '<') {
if (tok->infile) {
(void) fprintf(stderr, "Error: Ambiguous I/O redirection\n");
return -1;
}
parsing_state |= ST_INFILE;
buf++;
continue;
}
if (*buf == '>') {
if (tok->outfile) {
(void) fprintf(stderr, "Error: Ambiguous I/O redirection\n");
return -1;
}
parsing_state |= ST_OUTFILE;
buf ++;
continue;
}
if (*buf == '\'' || *buf == '\"') {
/* Detect quoted tokens */
buf++;
next = strchr (buf, *(buf-1));
} else {
/* Find next delimiter */
next = buf + strcspn (buf, delims);
}
if (next == NULL) {
/* Returned by strchr(); this means that the closing
quote was not found. */
(void) fprintf (stderr, "Error: unmatched %c.\n", *(buf-1));
return -1;
}
/* Terminate the token */
*next = '\0';
/* Record the token as either the next argument or the i/o file */
switch (parsing_state) {
case ST_NORMAL:
tok->argv[tok->argc++] = buf;
break;
case ST_INFILE:
tok->infile = buf;
break;
case ST_OUTFILE:
tok->outfile = buf;
break;
default:
(void) fprintf(stderr, "Error: Ambiguous I/O redirection\n");
return -1;
}
parsing_state = ST_NORMAL;
/* Check if argv is full */
if (tok->argc >= MAXARGS-1) break;
buf = next + 1;
}
if (parsing_state != ST_NORMAL) {
(void) fprintf(stderr,
"Error: must provide file name for redirection\n");
return -1;
}
/* The argument list must end with a NULL pointer */
tok->argv[tok->argc] = NULL;
if (tok->argc == 0) /* ignore blank line */
return 1;
if (!strcmp(tok->argv[0], "quit")) { /* quit command */
tok->builtins = BUILTIN_QUIT;
} else if (!strcmp(tok->argv[0], "jobs")) { /* jobs command */
tok->builtins = BUILTIN_JOBS;
} else if (!strcmp(tok->argv[0], "bg")) { /* bg command */
tok->builtins = BUILTIN_BG;
} else if (!strcmp(tok->argv[0], "fg")) { /* fg command */
tok->builtins = BUILTIN_FG;
} else {
tok->builtins = BUILTIN_NONE;
}
/* Should the job run in the background? */
if ((is_bg = (*tok->argv[tok->argc-1] == '&')) != 0)
tok->argv[--tok->argc] = NULL;
return is_bg;
}
static krb5_error_code
get_new_tickets(krb5_context context,
krb5_principal principal,
krb5_ccache ccache,
krb5_deltat ticket_life,
int interactive)
{
krb5_error_code ret;
krb5_get_init_creds_opt *opt;
krb5_creds cred;
char passwd[256];
krb5_deltat start_time = 0;
krb5_deltat renew = 0;
const char *renewstr = NULL;
krb5_enctype *enctype = NULL;
krb5_ccache tempccache;
krb5_init_creds_context icc;
krb5_keytab kt = NULL;
int need_prompt;
int will_use_keytab = (use_keytab || keytab_str);
passwd[0] = '\0';
if (password_file) {
FILE *f;
if (strcasecmp("STDIN", password_file) == 0)
f = stdin;
else
f = fopen(password_file, "r");
if (f == NULL)
krb5_errx(context, 1, "Failed to open the password file %s",
password_file);
if (fgets(passwd, sizeof(passwd), f) == NULL)
krb5_errx(context, 1,
N_("Failed to read password from file %s", ""),
password_file);
if (f != stdin)
fclose(f);
passwd[strcspn(passwd, "\n")] = '\0';
}
#if defined(__APPLE__) && !defined(__APPLE_TARGET_EMBEDDED__)
if (passwd[0] == '\0' && !will_use_keytab && home_directory_flag) {
const char *realm;
OSStatus osret;
UInt32 length;
void *buffer;
char *name;
realm = krb5_principal_get_realm(context, principal);
ret = krb5_unparse_name_flags(context, principal,
KRB5_PRINCIPAL_UNPARSE_NO_REALM, &name);
if (ret)
goto nopassword;
osret = SecKeychainFindGenericPassword(NULL, (UInt32)strlen(realm), realm,
(UInt32)strlen(name), name,
&length, &buffer, &passwordItem);
free(name);
if (osret != noErr)
goto nopassword;
if (length < sizeof(passwd) - 1) {
memcpy(passwd, buffer, length);
passwd[length] = '\0';
}
SecKeychainItemFreeContent(NULL, buffer);
nopassword:
do { } while(0);
}
#endif
memset(&cred, 0, sizeof(cred));
ret = krb5_get_init_creds_opt_alloc (context, &opt);
if (ret)
krb5_err(context, 1, ret, "krb5_get_init_creds_opt_alloc");
krb5_get_init_creds_opt_set_default_flags(context, "kinit",
krb5_principal_get_realm(context, principal), opt);
if(forwardable_flag != -1)
krb5_get_init_creds_opt_set_forwardable (opt, forwardable_flag);
if(proxiable_flag != -1)
krb5_get_init_creds_opt_set_proxiable (opt, proxiable_flag);
if(anonymous_flag)
krb5_get_init_creds_opt_set_anonymous (opt, anonymous_flag);
if (pac_flag != -1)
krb5_get_init_creds_opt_set_pac_request(context, opt,
pac_flag ? TRUE : FALSE);
if (canonicalize_flag)
krb5_get_init_creds_opt_set_canonicalize(context, opt, TRUE);
if (pk_enterprise_flag || enterprise_flag || canonicalize_flag || windows_flag)
krb5_get_init_creds_opt_set_win2k(context, opt, TRUE);
if (pk_user_id || ent_user_id || anonymous_flag) {
ret = krb5_get_init_creds_opt_set_pkinit(context, opt,
principal,
pk_user_id,
pk_x509_anchors,
NULL,
NULL,
pk_use_enckey ? 2 : 0 |
anonymous_flag ? 4 : 0,
krb5_prompter_posix,
NULL,
passwd);
if (ret)
krb5_err(context, 1, ret, "krb5_get_init_creds_opt_set_pkinit");
if (ent_user_id)
krb5_get_init_creds_opt_set_pkinit_user_cert(context, opt, ent_user_id);
}
if (addrs_flag != -1)
krb5_get_init_creds_opt_set_addressless(context, opt,
addrs_flag ? FALSE : TRUE);
if (renew_life == NULL && renewable_flag)
renewstr = "1 month";
if (renew_life)
renewstr = renew_life;
if (renewstr) {
renew = parse_time (renewstr, "s");
if (renew < 0)
errx (1, "unparsable time: %s", renewstr);
krb5_get_init_creds_opt_set_renew_life (opt, renew);
}
if(ticket_life != 0)
krb5_get_init_creds_opt_set_tkt_life (opt, ticket_life);
if(start_str) {
int tmp = parse_time (start_str, "s");
if (tmp < 0)
errx (1, N_("unparsable time: %s", ""), start_str);
start_time = tmp;
}
if(etype_str.num_strings) {
int i;
enctype = malloc(etype_str.num_strings * sizeof(*enctype));
if(enctype == NULL)
errx(1, "out of memory");
for(i = 0; i < etype_str.num_strings; i++) {
ret = krb5_string_to_enctype(context,
etype_str.strings[i],
&enctype[i]);
if(ret)
krb5_err(context, 1, ret, "unrecognized enctype: %s",
etype_str.strings[i]);
}
krb5_get_init_creds_opt_set_etype_list(opt, enctype,
etype_str.num_strings);
}
ret = krb5_init_creds_init(context, principal,
krb5_prompter_posix, NULL,
start_time, opt, &icc);
if (ret)
krb5_err (context, 1, ret, "krb5_init_creds_init");
if (server_str) {
ret = krb5_init_creds_set_service(context, icc, server_str);
if (ret)
krb5_err (context, 1, ret, "krb5_init_creds_set_service");
}
if (kdc_hostname)
krb5_init_creds_set_kdc_hostname(context, icc, kdc_hostname);
if (fast_armor_cache_string) {
krb5_ccache fastid;
ret = krb5_cc_resolve(context, fast_armor_cache_string, &fastid);
if (ret)
krb5_err(context, 1, ret, "krb5_cc_resolve(FAST cache)");
ret = krb5_init_creds_set_fast_ccache(context, icc, fastid);
if (ret)
krb5_err(context, 1, ret, "krb5_init_creds_set_fast_ccache");
}
if(will_use_keytab) {
if(keytab_str)
ret = krb5_kt_resolve(context, keytab_str, &kt);
else
ret = krb5_kt_default(context, &kt);
if (ret)
krb5_err (context, 1, ret, "resolving keytab");
ret = krb5_init_creds_set_keytab(context, icc, kt);
if (ret)
krb5_err (context, 1, ret, "krb5_init_creds_set_keytab");
}
need_prompt = !(pk_user_id || ent_user_id || anonymous_flag || use_keytab || keytab_str);
if (interactive && passwd[0] == '\0' && need_prompt) {
char *p, *prompt;
krb5_unparse_name(context, principal, &p);
asprintf (&prompt, N_("%s's Password: "******""), p);
free(p);
if (UI_UTIL_read_pw_string(passwd, sizeof(passwd)-1, prompt, 0)){
memset(passwd, 0, sizeof(passwd));
errx(1, "failed to read password");
}
free (prompt);
}
if (passwd[0]) {
ret = krb5_init_creds_set_password(context, icc, passwd);
if (ret)
krb5_err(context, 1, ret, "krb5_init_creds_set_password");
}
ret = krb5_init_creds_get(context, icc);
#ifdef __APPLE__
/*
* Save password in Keychain
*/
if (ret == 0 && keychain_flag && passwordItem == NULL) {
krb5_error_code ret2;
const char *realm;
char *name;
realm = krb5_principal_get_realm(context, principal);
ret2 = krb5_unparse_name_flags(context, principal, KRB5_PRINCIPAL_UNPARSE_NO_REALM, &name);
if (ret2 == 0) {
(void)SecKeychainAddGenericPassword(NULL,
(UInt32)strlen(realm), realm,
(UInt32)strlen(name), name,
(UInt32)strlen(passwd), passwd,
NULL);
free(name);
}
}
#endif
memset(passwd, 0, sizeof(passwd));
switch(ret){
case 0:
break;
case KRB5_LIBOS_PWDINTR: /* don't print anything if it was just C-c:ed */
exit(1);
case KRB5KRB_AP_ERR_BAD_INTEGRITY:
case KRB5KRB_AP_ERR_MODIFIED:
case KRB5KDC_ERR_PREAUTH_FAILED:
case KRB5_GET_IN_TKT_LOOP:
#ifdef __APPLE__
if (passwordItem)
SecKeychainItemDelete(passwordItem);
#endif
krb5_errx(context, 1, N_("Password incorrect", ""));
break;
case KRB5KRB_AP_ERR_V4_REPLY:
krb5_errx(context, 1, N_("Looks like a Kerberos 4 reply", ""));
break;
case KRB5KDC_ERR_KEY_EXPIRED:
krb5_errx(context, 1, N_("Password expired", ""));
break;
default:
krb5_err(context, 1, ret, "krb5_get_init_creds");
}
ret = krb5_init_creds_get_creds(context, icc, &cred);
if (ret)
krb5_err(context, 1, ret, "krb5_init_creds_get_creds");
krb5_process_last_request(context, opt, icc);
ret = krb5_cc_new_unique(context, krb5_cc_get_type(context, ccache),
NULL, &tempccache);
if (ret)
krb5_err (context, 1, ret, "krb5_cc_new_unique");
ret = krb5_init_creds_store(context, icc, tempccache);
if (ret)
krb5_err(context, 1, ret, "krb5_init_creds_store");
ret = krb5_init_creds_store_config(context, icc, tempccache);
if (ret)
krb5_warn(context, ret, "krb5_init_creds_store_config");
ret = krb5_init_creds_warn_user(context, icc);
if (ret)
krb5_warn(context, ret, "krb5_init_creds_warn_user");
ret = krb5_cc_move(context, tempccache, ccache);
if (ret) {
(void)krb5_cc_destroy(context, tempccache);
krb5_err (context, 1, ret, "krb5_cc_move");
}
if (switch_cache_flags)
krb5_cc_switch(context, ccache);
if (ok_as_delegate_flag || windows_flag || use_referrals_flag) {
unsigned char d = 0;
krb5_data data;
if (ok_as_delegate_flag || windows_flag)
d |= 1;
if (use_referrals_flag || windows_flag)
d |= 2;
data.length = 1;
data.data = &d;
krb5_cc_set_config(context, ccache, NULL, "realm-config", &data);
}
if (enctype)
free(enctype);
krb5_init_creds_free(context, icc);
krb5_get_init_creds_opt_free(context, opt);
if (kt)
krb5_kt_close(context, kt);
#ifdef __APPLE__
if (passwordItem)
CFRelease(passwordItem);
#endif
return 0;
}
UINT32 FrmStrcspn( const CHAR* cs, const CHAR* ct ) { return (UINT32)strcspn( cs, ct ); }
static void def_load (void)
{
int i;
FILE *fp;
char buf[1024], *name, *value, *s;
/*
* Open the configuration definitions file.
*/
fp = fopen (def_fname, "r");
if (NULL == fp) {
int err = errno;
SYSLOG ((LOG_CRIT, "cannot open login definitions %s [%s]",
def_fname, strerror (err)));
exit (EXIT_FAILURE);
}
/*
* Set the initialized flag.
* (do it early to prevent recursion in putdef_str())
*/
def_loaded = true;
/*
* Go through all of the lines in the file.
*/
while (fgets (buf, (int) sizeof (buf), fp) != NULL) {
/*
* Trim trailing whitespace.
*/
for (i = (int) strlen (buf) - 1; i >= 0; --i) {
if (!isspace (buf[i])) {
break;
}
}
i++;
buf[i] = '\0';
/*
* Break the line into two fields.
*/
name = buf + strspn (buf, " \t"); /* first nonwhite */
if (*name == '\0' || *name == '#')
continue; /* comment or empty */
s = name + strcspn (name, " \t"); /* end of field */
if (*s == '\0')
continue; /* only 1 field?? */
*s++ = '\0';
value = s + strspn (s, " \"\t"); /* next nonwhite */
*(value + strcspn (value, "\"")) = '\0';
/*
* Store the value in def_table.
*
* Ignore failures to load the login.defs file.
* The error was already reported to the user and to
* syslog. The tools will just use their default values.
*/
(void)putdef_str (name, value);
}
if (ferror (fp) != 0) {
int err = errno;
SYSLOG ((LOG_CRIT, "cannot read login definitions %s [%s]",
def_fname, strerror (err)));
exit (EXIT_FAILURE);
}
(void) fclose (fp);
}
Bit8u FCB_Parsename(Bit16u seg,Bit16u offset,Bit8u parser ,char *string, Bit8u *change) {
char * string_begin=string;
Bit8u ret=0;
if (!(parser & PARSE_DFLT_DRIVE)) {
// default drive forced, this intentionally invalidates an extended FCB
mem_writeb(PhysMake(seg,offset),0);
}
DOS_FCB fcb(seg,offset,false); // always a non-extended FCB
bool hasdrive,hasname,hasext,finished;
hasdrive=hasname=hasext=finished=false;
Bitu index=0;
Bit8u fill=' ';
/* First get the old data from the fcb */
#ifdef _MSC_VER
#pragma pack (1)
#endif
union {
struct {
char drive[2];
char name[9];
char ext[4];
} GCC_ATTRIBUTE (packed) part;
char full[DOS_FCBNAME];
} fcb_name;
#ifdef _MSC_VER
#pragma pack()
#endif
/* Get the old information from the previous fcb */
fcb.GetName(fcb_name.full);
fcb_name.part.drive[0]-='A'-1;fcb_name.part.drive[1]=0;
fcb_name.part.name[8]=0;fcb_name.part.ext[3]=0;
/* Strip of the leading sepetaror */
if((parser & PARSE_SEP_STOP) && *string) { //ignore leading seperator
char sep[] = FCB_SEP;char a[2];
a[0]= *string;a[1]='\0';
if (strcspn(a,sep)==0) string++;
}
/* strip leading spaces */
while((*string==' ')||(*string=='\t')) string++;
/* Check for a drive */
if (string[1]==':') {
fcb_name.part.drive[0]=0;
hasdrive=true;
if (isalpha(string[0]) && Drives[toupper(string[0])-'A']) {
fcb_name.part.drive[0]=(char)(toupper(string[0])-'A'+1);
} else ret=0xff;
string+=2;
}
/* Special checks for . and .. */
if (string[0]=='.') {
string++;
if (!string[0]) {
hasname=true;
ret=PARSE_RET_NOWILD;
strcpy(fcb_name.part.name,". ");
goto savefcb;
}
if (string[1]=='.' && !string[1]) {
string++;
hasname=true;
ret=PARSE_RET_NOWILD;
strcpy(fcb_name.part.name,".. ");
goto savefcb;
}
goto checkext;
}
/* Copy the name */
hasname=true;finished=false;fill=' ';index=0;
while (index<8) {
if (!finished) {
if (string[0]=='*') {fill='?';fcb_name.part.name[index]='?';if (!ret) ret=1;finished=true;}
else if (string[0]=='?') {fcb_name.part.name[index]='?';if (!ret) ret=1;}
else if (isvalid(string[0])) {fcb_name.part.name[index]=(char)(toupper(string[0]));}
else { finished=true;continue; }
string++;
} else {
fcb_name.part.name[index]=fill;
}
index++;
}
if (!(string[0]=='.')) goto savefcb;
string++;
checkext:
/* Copy the extension */
hasext=true;finished=false;fill=' ';index=0;
while (index<3) {
if (!finished) {
if (string[0]=='*') {fill='?';fcb_name.part.ext[index]='?';finished=true;}
else if (string[0]=='?') {fcb_name.part.ext[index]='?';if (!ret) ret=1;}
else if (isvalid(string[0])) {fcb_name.part.ext[index]=(char)(toupper(string[0]));}
else { finished=true;continue; }
string++;
} else {
fcb_name.part.ext[index]=fill;
}
index++;
}
savefcb:
if (!hasdrive & !(parser & PARSE_DFLT_DRIVE)) fcb_name.part.drive[0] = 0;
if (!hasname & !(parser & PARSE_BLNK_FNAME)) strcpy(fcb_name.part.name," ");
if (!hasext & !(parser & PARSE_BLNK_FEXT)) strcpy(fcb_name.part.ext," ");
fcb.SetName(fcb_name.part.drive[0],fcb_name.part.name,fcb_name.part.ext);
*change=(Bit8u)(string-string_begin);
return ret;
}
/*
* See <Documentation/x86/x86_64/boot-options.txt> for the iommu kernel
* parameter documentation.
*/
static __init int iommu_setup(char *p)
{
iommu_merge = 1;
if (!p)
return -EINVAL;
while (*p) {
if (!strncmp(p, "off", 3))
no_iommu = 1;
/* gart_parse_options has more force support */
if (!strncmp(p, "force", 5))
force_iommu = 1;
if (!strncmp(p, "noforce", 7)) {
iommu_merge = 0;
force_iommu = 0;
}
if (!strncmp(p, "biomerge", 8)) {
iommu_merge = 1;
force_iommu = 1;
}
if (!strncmp(p, "panic", 5))
panic_on_overflow = 1;
if (!strncmp(p, "nopanic", 7))
panic_on_overflow = 0;
if (!strncmp(p, "merge", 5)) {
iommu_merge = 1;
force_iommu = 1;
}
if (!strncmp(p, "nomerge", 7))
iommu_merge = 0;
if (!strncmp(p, "forcesac", 8))
iommu_sac_force = 1;
if (!strncmp(p, "allowdac", 8))
forbid_dac = 0;
if (!strncmp(p, "nodac", 5))
forbid_dac = 1;
if (!strncmp(p, "usedac", 6)) {
forbid_dac = -1;
return 1;
}
#ifdef CONFIG_SWIOTLB
if (!strncmp(p, "soft", 4))
swiotlb = 1;
#endif
if (!strncmp(p, "pt", 2))
iommu_pass_through = 1;
if (!strncmp(p, "group_mf", 8))
iommu_group_mf = 1;
gart_parse_options(p);
#ifdef CONFIG_CALGARY_IOMMU
if (!strncmp(p, "calgary", 7))
use_calgary = 1;
#endif /* CONFIG_CALGARY_IOMMU */
p += strcspn(p, ",");
if (*p == ',')
++p;
}
return 0;
}
void build_request (const char *url)
{
char tmp[10];
int i;
bzero(host, MAXHOSTNAMELEN);
bzero(request, REQUEST_SIZE);
/* 协议适配
* */
if (force_reload && proxyhost != NULL && http10 < 1) {
http10=1;
}
if (method == METHOD_HEAD && http10 < 1) {
http10=1;
}
if (method == METHOD_OPTIONS && http10 < 2) {
http10=2;
}
if (method == METHOD_TRACE && http10 < 2) {
http10=2;
}
switch (method) {
default:
case METHOD_GET:
strcpy(request, "GET");
break;
case METHOD_HEAD:
strcpy(request, "HEAD");
break;
case METHOD_OPTIONS:
strcpy(request, "OPTIONS");
break;
case METHOD_TRACE:
strcpy(request, "TRACE");
break;
}
strcat(request, " ");
if (NULL == strstr(url, "://")) {
fprintf(stderr, "\n%s: is not a valid URL.\n",url);
exit(2);
}
if (strlen(url) > 1500) {
fprintf(stderr,"URL is too long.\n");
exit(2);
}
if (proxyhost == NULL) {
if (0 != strncasecmp("http://", url, 7)) {
fprintf(stderr,"\nOnly HTTP protocol is directly supported, set --proxy for others.\n");
exit(2);
}
}
/* protocol/host delimiter */
i = strstr(url, "://") - url + 3;
/* printf("%d\n",i); */
if (strchr(url + i, '/') == NULL) {
fprintf(stderr,"\nInvalid URL syntax - hostname don't ends with '/'.\n");
exit(2);
}
if (proxyhost == NULL) {
/* get port from hostname */
if (index(url + i, ':') != NULL && index(url + i, ':') < index(url + i, '/')) {
strncpy(host, url + i, strchr(url + i, ':') - url - i);
bzero(tmp, 10);
strncpy(tmp, index(url + i, ':') + 1, strchr(url + i, '/') - index(url + i, ':') - 1);
/* printf("tmp=%s\n",tmp); */
proxyport = atoi(tmp);
if (proxyport == 0) {
proxyport=80;
}
} else {
strncpy(host, url + i, strcspn(url + i, "/"));
}
// printf("Host=%s\n",host);
strcat(request + strlen(request), url + i + strcspn(url + i, "/"));
} else {
// printf("ProxyHost=%s\nProxyPort=%d\n",proxyhost,proxyport);
strcat(request, url);
}
if (http10 == 1) {
strcat(request, " HTTP/1.0");
} else if (http10 == 2) {
strcat(request, " HTTP/1.1");
}
strcat(request,"\r\n");
if (http10 > 0) {
strcat(request, "User-Agent: WebBench "PROGRAM_VERSION"\r\n");
}
if (proxyhost == NULL && http10 > 0) {
strcat(request, "Host: ");
strcat(request, host);
strcat(request, "\r\n");
}
if (force_reload && proxyhost != NULL) {
strcat(request, "Pragma: no-cache\r\n");
}
if (http10 > 1) {
strcat(request, "Connection: close\r\n");
}
/* add empty line at end */
if (http10 > 0) {
strcat(request, "\r\n");
}
// printf("Req=%s\n",request);
}
/*
** Send extended string to socket (dynamic webpages).
**
** IN:
** HTTPSRV_STRUCT *server - server structure.
** HTTPSRV_SESSION_STRUCT *session - session for sending.
** char *str - string to send.
** uint_32 length - length of source string.
**
** OUT:
** none
**
** Return Value:
** int - number of bytes processed.
*/
static _mqx_int httpsrv_sendextstr(HTTPSRV_STRUCT *server, HTTPSRV_SESSION_STRUCT *session, char *str, uint_32 length)
{
char *src;
int len, res;
int add = 0;
char fname[HTTPSRVCFG_MAX_SCRIPT_LN + 1];
uint_32 old_data = session->buffer.offset;
src = str;
fname[0] = 0;
if (session->response.script_token)
{
// script token found
len = (int)strcspn(src, " ;%<>\r\n\t");
if (len > 1 && len < HTTPSRVCFG_MAX_SCRIPT_LN)
{
HTTPSRV_SCRIPT_MSG* msg_ptr;
snprintf(fname, len+1, "%s", src);
/* Form up message for handler task and send it */
msg_ptr = _msg_alloc(server->script_msg_pool);
if (msg_ptr != NULL)
{
msg_ptr->header.TARGET_QID = server->script_msgq;
msg_ptr->header.SOURCE_QID = server->script_msgq;
msg_ptr->header.SIZE = sizeof(HTTPSRV_SCRIPT_MSG);
msg_ptr->session = session;
msg_ptr->type = HTTPSRV_SSI_CALLBACK;
msg_ptr->name = fname;
msg_ptr->ses_tid = _task_get_id();
_msgq_send(msg_ptr);
/* wait until SSI is processed */
_task_block();
}
}
if (src[len] == '%' && src[len + 1] == '>')
{
session->response.script_token = 0;
len += 1;
}
len++;
}
else
{
for (len = 0; *src && len < length; src++, len++)
{
if (src[0] == '<' && src[1] == '%')
{
session->response.script_token = 1;
src += 2;
add = 2;
break;
}
}
res = send(session->sock, str, len, 0);
session->buffer.offset = 0;
_mem_zero(session->buffer.data, (HTTPSRVCFG_SES_BUFFER_SIZE & PSP_MEMORY_ALIGNMENT_MASK));
if (res < 0)
{
session->response.script_token = 0;
res = errno;
if (res != EAGAIN)
{
len = 0;
}
}
else if (len != res)
{
session->response.script_token = 0;
}
}
return ((len+add)-old_data);
}
bool Database::validDBName( const string& ns ) {
if ( ns.size() == 0 || ns.size() > 64 )
return false;
size_t good = strcspn( ns.c_str() , "/\\. \"" );
return good == ns.size();
}
int find_modifiers (buffer_t *command_line, pipeline_t *pipeline)
{
int amp; /* '&' position */
int lt, gt;
int len, truncated;
int i, j, k;
pipeline->ground = FOREGROUND;
pipeline->file_in[0] = '\0';
pipeline->file_out[0] = '\0';
truncated = 0;
len = command_line->length;
/* Find &, if any. */
amp = strcspn (command_line->buffer, "&");
if (amp != (len - 1))
pipeline->ground = BACKGROUND;
for (i = amp + 1; i < len - 1; i++)
if (!isblk (command_line->buffer[i]))
truncated |= PARSER_STUFF_AFTER_AMP;
command_line->buffer[amp] = '\0';
command_line->length = amp;
len = amp;
/* Find output redirect. */
lt = strcspn (command_line->buffer, "<");
if (lt != len)
{
for (i = lt + 1; isblk(command_line->buffer[i]); i++);
/* printf ("lt found (%s)\n", command_line->buffer+i); */
j = 0;
while ((i < len) && (i < MAX_FILENAME) &&
(!isblk(command_line->buffer[i])) && (command_line->buffer[i] != '<'))
pipeline->file_in[j++] = command_line->buffer[i++];
pipeline->file_in[j] = '\0';
}
/* printf ("lt now (%s)\n", pipeline->file_in); */
gt = strcspn (command_line->buffer, ">");
if (gt != len)
{
for (i = gt + 1; isblk(command_line->buffer[i]); i++);
/* printf ("gt found (%s)\n", command_line->buffer+i); */
j = 0;
while ((i < len) && (i < MAX_FILENAME) &&
(!isblk(command_line->buffer[i])) && (command_line->buffer[i] != '<'))
pipeline->file_out[j++] = command_line->buffer[i++];
pipeline->file_out[j] = '\0';
}
/* printf ("gt now (%s)\n", pipeline->file_out); */
k = lt < gt ? lt : gt;
k = k < len ? k : k + 1;
command_line->buffer[k - 1] = '\0';
command_line->length = k;
debug (truncated && PARSER_STUFF_AFTER_AMP, "Nothing allowed after '&'");
return truncated;
}
static void srt_to_ass(AVCodecContext *avctx, AVBPrint *dst,
const char *in, int x1, int y1, int x2, int y2)
{
char *param, buffer[128], tmp[128];
int len, tag_close, sptr = 1, line_start = 1, an = 0, end = 0;
SrtStack stack[16];
stack[0].tag[0] = 0;
strcpy(stack[0].param[PARAM_SIZE], "{\\fs}");
strcpy(stack[0].param[PARAM_COLOR], "{\\c}");
strcpy(stack[0].param[PARAM_FACE], "{\\fn}");
if (x1 >= 0 && y1 >= 0) {
if (x2 >= 0 && y2 >= 0 && (x2 != x1 || y2 != y1))
av_bprintf(dst, "{\\an1}{\\move(%d,%d,%d,%d)}", x1, y1, x2, y2);
else
av_bprintf(dst, "{\\an1}{\\pos(%d,%d)}", x1, y1);
}
for (; !end && *in; in++) {
switch (*in) {
case '\r':
break;
case '\n':
if (line_start) {
end = 1;
break;
}
rstrip_spaces_buf(dst);
av_bprintf(dst, "\\N");
line_start = 1;
break;
case ' ':
if (!line_start)
av_bprint_chars(dst, *in, 1);
break;
case '{': /* skip all {\xxx} substrings except for {\an%d}
and all microdvd like styles such as {Y:xxx} */
len = 0;
an += sscanf(in, "{\\an%*1u}%n", &len) >= 0 && len > 0;
if ((an != 1 && (len = 0, sscanf(in, "{\\%*[^}]}%n", &len) >= 0 && len > 0)) ||
(len = 0, sscanf(in, "{%*1[CcFfoPSsYy]:%*[^}]}%n", &len) >= 0 && len > 0)) {
in += len - 1;
} else
av_bprint_chars(dst, *in, 1);
break;
case '<':
tag_close = in[1] == '/';
len = 0;
if (sscanf(in+tag_close+1, "%127[^>]>%n", buffer, &len) >= 1 && len > 0) {
if ((param = strchr(buffer, ' ')))
*param++ = 0;
if ((!tag_close && sptr < FF_ARRAY_ELEMS(stack)) ||
( tag_close && sptr > 0 && !strcmp(stack[sptr-1].tag, buffer))) {
int i, j, unknown = 0;
in += len + tag_close;
if (!tag_close)
memset(stack+sptr, 0, sizeof(*stack));
if (!strcmp(buffer, "font")) {
if (tag_close) {
for (i=PARAM_NUMBER-1; i>=0; i--)
if (stack[sptr-1].param[i][0])
for (j=sptr-2; j>=0; j--)
if (stack[j].param[i][0]) {
av_bprintf(dst, "%s", stack[j].param[i]);
break;
}
} else {
while (param) {
if (!strncmp(param, "size=", 5)) {
unsigned font_size;
param += 5 + (param[5] == '"');
if (sscanf(param, "%u", &font_size) == 1) {
snprintf(stack[sptr].param[PARAM_SIZE],
sizeof(stack[0].param[PARAM_SIZE]),
"{\\fs%u}", font_size);
}
} else if (!strncmp(param, "color=", 6)) {
param += 6 + (param[6] == '"');
snprintf(stack[sptr].param[PARAM_COLOR],
sizeof(stack[0].param[PARAM_COLOR]),
"{\\c&H%X&}",
html_color_parse(avctx, param));
} else if (!strncmp(param, "face=", 5)) {
param += 5 + (param[5] == '"');
len = strcspn(param,
param[-1] == '"' ? "\"" :" ");
av_strlcpy(tmp, param,
FFMIN(sizeof(tmp), len+1));
param += len;
snprintf(stack[sptr].param[PARAM_FACE],
sizeof(stack[0].param[PARAM_FACE]),
"{\\fn%s}", tmp);
}
if ((param = strchr(param, ' ')))
param++;
}
for (i=0; i<PARAM_NUMBER; i++)
if (stack[sptr].param[i][0])
av_bprintf(dst, "%s", stack[sptr].param[i]);
}
} else if (!buffer[1] && strspn(buffer, "bisu") == 1) {
av_bprintf(dst, "{\\%c%d}", buffer[0], !tag_close);
} else {
unknown = 1;
snprintf(tmp, sizeof(tmp), "</%s>", buffer);
}
if (tag_close) {
sptr--;
} else if (unknown && !strstr(in, tmp)) {
in -= len + tag_close;
av_bprint_chars(dst, *in, 1);
} else
av_strlcpy(stack[sptr++].tag, buffer,
sizeof(stack[0].tag));
break;
}
}
default:
av_bprint_chars(dst, *in, 1);
break;
}
if (*in != ' ' && *in != '\r' && *in != '\n')
line_start = 0;
}
while (dst->len >= 2 && !strncmp(&dst->str[dst->len - 2], "\\N", 2))
dst->len -= 2;
dst->str[dst->len] = 0;
rstrip_spaces_buf(dst);
}
struct uct_dynkomi *
uct_dynkomi_init_adaptive(struct uct *u, char *arg, struct board *b)
{
struct uct_dynkomi *d = calloc2(1, sizeof(*d));
d->uct = u;
d->permove = adaptive_permove;
d->persim = adaptive_persim;
d->done = generic_done;
struct dynkomi_adaptive *a = calloc2(1, sizeof(*a));
d->data = a;
a->lead_moves = board_large(b) ? 20 : 4; // XXX
a->max_losing_komi = 30;
a->losing_komi_stop = 1.0f;
a->no_komi_at_game_end = true;
a->indicator = komi_by_value;
a->adapter = adapter_sigmoid;
a->adapt_rate = -18;
a->adapt_phase = 0.65;
a->adapt_moves = 200;
a->adapt_dir = -0.5;
a->zone_red = 0.45;
a->zone_green = 0.50;
a->score_step = 1;
a->use_komi_ratchet = true;
a->komi_ratchet_maxage = 0;
a->komi_ratchet = 1000;
if (arg) {
char *optspec, *next = arg;
while (*next) {
optspec = next;
next += strcspn(next, ":");
if (*next) { *next++ = 0; } else { *next = 0; }
char *optname = optspec;
char *optval = strchr(optspec, '=');
if (optval) *optval++ = 0;
if (!strcasecmp(optname, "lead_moves") && optval) {
/* Do not adjust komi adaptively for first
* N moves. */
a->lead_moves = atoi(optval);
} else if (!strcasecmp(optname, "max_losing_komi") && optval) {
a->max_losing_komi = atof(optval);
} else if (!strcasecmp(optname, "losing_komi_stop") && optval) {
a->losing_komi_stop = atof(optval);
} else if (!strcasecmp(optname, "no_komi_at_game_end")) {
a->no_komi_at_game_end = !optval || atoi(optval);
} else if (!strcasecmp(optname, "indicator")) {
/* Adaptatation indicator - how to decide
* the adaptation rate and direction. */
if (!strcasecmp(optval, "value")) {
/* Winrate w/ komi so far. */
a->indicator = komi_by_value;
} else if (!strcasecmp(optval, "score")) {
/* Expected score w/ current komi. */
a->indicator = komi_by_score;
} else {
fprintf(stderr, "UCT: Invalid indicator %s\n", optval);
exit(1);
}
/* value indicator settings */
} else if (!strcasecmp(optname, "zone_red") && optval) {
a->zone_red = atof(optval);
} else if (!strcasecmp(optname, "zone_green") && optval) {
a->zone_green = atof(optval);
} else if (!strcasecmp(optname, "score_step") && optval) {
a->score_step = atoi(optval);
} else if (!strcasecmp(optname, "score_step_byavg") && optval) {
a->score_step_byavg = atof(optval);
} else if (!strcasecmp(optname, "use_komi_ratchet")) {
a->use_komi_ratchet = !optval || atoi(optval);
} else if (!strcasecmp(optname, "losing_komi_ratchet")) {
a->losing_komi_ratchet = !optval || atoi(optval);
} else if (!strcasecmp(optname, "komi_ratchet_age") && optval) {
a->komi_ratchet_maxage = atoi(optval);
/* score indicator settings */
} else if (!strcasecmp(optname, "adapter") && optval) {
/* Adaptatation method. */
if (!strcasecmp(optval, "sigmoid")) {
a->adapter = adapter_sigmoid;
} else if (!strcasecmp(optval, "linear")) {
a->adapter = adapter_linear;
} else {
fprintf(stderr, "UCT: Invalid adapter %s\n", optval);
exit(1);
}
} else if (!strcasecmp(optname, "adapt_base") && optval) {
/* Adaptation base rate; see above. */
a->adapt_base = atof(optval);
} else if (!strcasecmp(optname, "adapt_rate") && optval) {
/* Adaptation slope; see above. */
a->adapt_rate = atof(optval);
} else if (!strcasecmp(optname, "adapt_phase") && optval) {
/* Adaptation phase shift; see above. */
a->adapt_phase = atof(optval);
} else if (!strcasecmp(optname, "adapt_moves") && optval) {
/* Adaptation move amount; see above. */
a->adapt_moves = atoi(optval);
} else if (!strcasecmp(optname, "adapt_aport")) {
a->adapt_aport = !optval || atoi(optval);
} else if (!strcasecmp(optname, "adapt_dir") && optval) {
/* Adaptation direction vector; see above. */
a->adapt_dir = atof(optval);
} else {
fprintf(stderr, "uct: Invalid dynkomi argument %s or missing value\n", optname);
exit(1);
}
}
}
return d;
}
static int
process_add_entry(struct archive_read *a, struct mtree *mtree,
struct mtree_option **global, const char *line,
struct mtree_entry **last_entry)
{
struct mtree_entry *entry;
struct mtree_option *iter;
const char *next, *eq;
size_t len;
int r;
if ((entry = malloc(sizeof(*entry))) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
entry->next = NULL;
entry->options = NULL;
entry->name = NULL;
entry->used = 0;
entry->full = 0;
/* Add this entry to list. */
if (*last_entry == NULL)
mtree->entries = entry;
else
(*last_entry)->next = entry;
*last_entry = entry;
len = strcspn(line, " \t\r\n");
if ((entry->name = malloc(len + 1)) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
memcpy(entry->name, line, len);
entry->name[len] = '\0';
parse_escapes(entry->name, entry);
line += len;
for (iter = *global; iter != NULL; iter = iter->next) {
r = add_option(a, &entry->options, iter->value,
strlen(iter->value));
if (r != ARCHIVE_OK)
return (r);
}
for (;;) {
next = line + strspn(line, " \t\r\n");
if (*next == '\0')
return (ARCHIVE_OK);
line = next;
next = line + strcspn(line, " \t\r\n");
eq = strchr(line, '=');
if (eq == NULL || eq > next)
len = next - line;
else
len = eq - line;
remove_option(&entry->options, line, len);
r = add_option(a, &entry->options, line, next - line);
if (r != ARCHIVE_OK)
return (r);
line = next;
}
}
int doc_parse(Doc *doc) {
char txt[BUFSIZ];
char buf[BUFSIZ];
char *cptr = NULL;
char *stateptr = NULL;
int r;
int s;
Node *tmp = NULL;
doc->numroots = 0;
doc->roots = (Node**)calloc(1, sizeof(Node*) * (doc->numroots + 1));
while (1) {
if (!stateptr) {
if (!pushtxt(doc->file, txt, stateptr))
return 0;
}
if (!tmp) {
stateptr = strstr(stateptr? stateptr: txt, "<");
if (!stateptr)
continue;
stateptr += 1;
cptr = strstr(stateptr, ">");
if (!cptr) {
if (!pushtxt(doc->file, txt, stateptr))
return 0;
cptr = strstr(stateptr, ">");
if (!cptr) {
return -1;
}
}
r = cptr - stateptr;
strncpy(buf, stateptr, r);
buf[r] = '\0';
buf[strcspn(buf, "\n\t ")] = '\0';
s = (*(stateptr-1+r) == '/');
if (s) {
s = strlen(buf);
if (s && (buf[s-1] == '/'))
buf[s-1] = '\0';
s = 1;
}
if (!stralpha(buf)) {
s = 2;
r = cptr - stateptr;
strncpy(buf, stateptr, r);
buf[r] = '\0';
} else {
cptr++;
}
tmp = new_node(buf);
tmp->single = s;
stateptr += r;
cptr = buf + strlen(buf);
attrib_parse(tmp, cptr);
doc_new_root(doc, tmp);
if (s)
tmp = NULL;
continue;
}
if (stateptr) {
stateptr++;
r = strcspn(stateptr, "<");
strncpy(buf, stateptr, r);
buf[r] = '\0';
tmp = node_add_text(tmp, buf);
stateptr = strstr(stateptr, "<");
} else {
r = strcspn(txt, "<");
strncpy(buf, txt, r);
buf[r] = '\0';
tmp = node_add_text(tmp, buf);
stateptr = strstr(txt, "<");
}
if (!stateptr)
continue;
stateptr += 1;
if (stateptr[0] == '/') {
cptr = strstr(stateptr, ">");
if (!cptr) {
if (!pushtxt(doc->file, txt, stateptr))
return 0;
cptr = strstr(stateptr, ">");
if (!cptr) {
return -1;
}
}
stateptr += 1;
r = cptr - stateptr;
strncpy(buf, stateptr, r);
buf[r] = '\0';
if (strcasecmp(buf, tmp->name)) {
fprintf(stderr, "malformed tag: <%s></%s>\n", tmp->name, buf);
}
tmp = tmp->parent;
stateptr += r;
continue;
}
cptr = strstr(stateptr, ">");
if (!cptr) {
if (!pushtxt(doc->file, txt, stateptr))
return 0;
cptr = strstr(stateptr, ">");
if (!cptr) {
return -1;
}
}
r = cptr - stateptr;
strncpy(buf, stateptr, r);
buf[r] = '\0';
buf[strcspn(buf, "\n\t ")] = '\0';
stateptr += r;
s = (*(stateptr - 1) == '/');
if (s) {
r = strlen(buf);
if (r && (buf[r-1] == '/'))
buf[r-1] = '\0';
}
tmp = node_add_child(tmp, new_node(buf), s);
cptr = buf + strlen(buf) + 1;
attrib_parse(tmp, cptr);
if (s) {
tmp = tmp->parent;
}
}
return 0;
}
int
fived_handle_reply (rr_dev dev, const char *reply, size_t nbytes)
{
uint okoffset = 2;
// a single T/B message (waiting for warm up (M109/M190)):
if (!strncasecmp ("T:", reply, 2) ||
!strncasecmp ("B:", reply, 2)) okoffset = 0;
if (okoffset==0 || !strncasecmp ("ok", reply, 2)) {
rr_dev_handle_ok (dev);
/* Parse values */
char *i;
for (i = (char*)reply + okoffset; i < reply + nbytes; ++i) {
if (isspace (*i))
continue;
switch (toupper (*i)) {
case 'T':
float_reply (dev, &i, RR_NOZZLE_TEMP);
break;
case 'B':
float_reply (dev, &i, RR_BED_TEMP);
break;
case 'C':
break;
case 'X':
float_reply (dev, &i, RR_X_POS);
break;
case 'Y':
float_reply (dev, &i, RR_Y_POS);
break;
case 'Z':
float_reply (dev, &i, RR_Z_POS);
break;
case 'E':
float_reply (dev, &i, RR_E_POS);
break;
default:
break;
//return rr_dev_emit_error (dev, RR_E_UNKNOWN_REPLY, reply, nbytes);
}
}
return 0;
} else if (!strncasecmp ("rs", reply, 2) ||
!strncasecmp ("resend", reply, 6)) {
/* check where the line number starts */
size_t n_start = strcspn (reply, "123456789");
if (n_start) {
long long lineno = strtoll (reply + n_start, NULL, 10);
if (dev->sendsize[RR_PRIO_SENTCACHE] +
dev->sendsize[RR_PRIO_RESEND] <= 1) {
/*
* oh dear - most likely we re-connected to a device that
* had problems mid-flow, now we need to re-send the
* line-number reset as if it was this line-no it is asking
* for a re-send of, or there will be no peace
*/
rr_dev_log (dev, RR_DEBUG_ALWAYS,
"resetting confused firmware with synthetic resend of line %d\n",
lineno);
rr_dev_enqueue_internal (dev, RR_PRIO_HIGH, "M110", 4, lineno);
/* re-start the print */
rr_dev_resend (dev, 0, "synthetic restart", 16);
return rr_dev_emit_error (dev, RR_E_UNSENT_RESEND, reply, nbytes);
}
return rr_dev_resend (dev, lineno, reply, nbytes);
} else
return rr_dev_emit_error (dev, RR_E_MALFORMED_RESEND_REQUEST, reply, nbytes);
} else if (!strncmp("!!", reply, 2)) {
return rr_dev_emit_error (dev, RR_E_HARDWARE_FAULT, reply, nbytes);
} else if (!strncasecmp ("start", reply, 5)) {
return rr_dev_handle_start (dev);
} else if (!strncasecmp ("echo", reply, 4)) {
return 0;
} else
return rr_dev_emit_error (dev, RR_E_UNKNOWN_REPLY, reply, nbytes);
}
/* {{{ php_url_parse
*/
PHPAPI php_url *php_url_parse_ex(char const *str, size_t length)
{
char port_buf[6];
php_url *ret = ecalloc(1, sizeof(php_url));
char const *s, *e, *p, *pp, *ue;
s = str;
ue = s + length;
/* parse scheme */
if ((e = memchr(s, ':', length)) && e != s) {
/* validate scheme */
p = s;
while (p < e) {
/* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
if (e + 1 < ue && e < s + strcspn(s, "?#")) {
goto parse_port;
} else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
e = 0;
goto parse_host;
} else {
goto just_path;
}
}
p++;
}
if (e + 1 == ue) { /* only scheme is available */
ret->scheme = zend_string_init(s, (e - s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));
return ret;
}
/*
* certain schemas like mailto: and zlib: may not have any / after them
* this check ensures we support those.
*/
if (*(e+1) != '/') {
/* check if the data we get is a port this allows us to
* correctly parse things like a.com:80
*/
p = e + 1;
while (p < ue && isdigit(*p)) {
p++;
}
if ((p == ue || *p == '/') && (p - e) < 7) {
goto parse_port;
}
ret->scheme = zend_string_init(s, (e-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));
s = e + 1;
goto just_path;
} else {
ret->scheme = zend_string_init(s, (e-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme));
if (e + 2 < ue && *(e + 2) == '/') {
s = e + 3;
if (zend_string_equals_literal_ci(ret->scheme, "file")) {
if (e + 3 < ue && *(e + 3) == '/') {
/* support windows drive letters as in:
file:///c:/somedir/file.txt
*/
if (e + 5 < ue && *(e + 5) == ':') {
s = e + 4;
}
goto just_path;
}
}
} else {
s = e + 1;
goto just_path;
}
}
} else if (e) { /* no scheme; starts with colon: look for port */
parse_port:
p = e + 1;
pp = p;
while (pp < ue && pp - p < 6 && isdigit(*pp)) {
pp++;
}
if (pp - p > 0 && pp - p < 6 && (pp == ue || *pp == '/')) {
zend_long port;
memcpy(port_buf, p, (pp - p));
port_buf[pp - p] = '\0';
port = ZEND_STRTOL(port_buf, NULL, 10);
if (port > 0 && port <= 65535) {
ret->port = (unsigned short) port;
if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
}
} else {
php_url_free(ret);
return NULL;
}
} else if (p == pp && pp == ue) {
php_url_free(ret);
return NULL;
} else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
} else {
goto just_path;
}
} else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
} else {
goto just_path;
}
parse_host:
/* Binary-safe strcspn(s, "/?#") */
e = ue;
if ((p = memchr(s, '/', e - s))) {
e = p;
}
if ((p = memchr(s, '?', e - s))) {
e = p;
}
if ((p = memchr(s, '#', e - s))) {
e = p;
}
/* check for login and password */
if ((p = zend_memrchr(s, '@', (e-s)))) {
if ((pp = memchr(s, ':', (p-s)))) {
ret->user = zend_string_init(s, (pp-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));
pp++;
ret->pass = zend_string_init(pp, (p-pp), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->pass), ZSTR_LEN(ret->pass));
} else {
ret->user = zend_string_init(s, (p-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));
}
s = p + 1;
}
/* check for port */
if (s < ue && *s == '[' && *(e-1) == ']') {
/* Short circuit portscan,
we're dealing with an
IPv6 embedded address */
p = NULL;
} else {
p = zend_memrchr(s, ':', (e-s));
}
if (p) {
if (!ret->port) {
p++;
if (e-p > 5) { /* port cannot be longer then 5 characters */
php_url_free(ret);
return NULL;
} else if (e - p > 0) {
zend_long port;
memcpy(port_buf, p, (e - p));
port_buf[e - p] = '\0';
port = ZEND_STRTOL(port_buf, NULL, 10);
if (port > 0 && port <= 65535) {
ret->port = (unsigned short)port;
} else {
php_url_free(ret);
return NULL;
}
}
p--;
}
} else {
p = e;
}
/* check if we have a valid host, if we don't reject the string as url */
if ((p-s) < 1) {
php_url_free(ret);
return NULL;
}
ret->host = zend_string_init(s, (p-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->host), ZSTR_LEN(ret->host));
if (e == ue) {
return ret;
}
s = e;
just_path:
e = ue;
p = memchr(s, '#', (e - s));
if (p) {
p++;
if (p < e) {
ret->fragment = zend_string_init(p, (e - p), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->fragment), ZSTR_LEN(ret->fragment));
}
e = p-1;
}
p = memchr(s, '?', (e - s));
if (p) {
p++;
if (p < e) {
ret->query = zend_string_init(p, (e - p), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->query), ZSTR_LEN(ret->query));
}
e = p-1;
}
if (s < e || s == ue) {
ret->path = zend_string_init(s, (e - s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->path), ZSTR_LEN(ret->path));
}
return ret;
}
/**
* Retrieve one field from a file like /proc/self/status. pattern
* should not include whitespace or the delimiter (':'). pattern matches only
* the beginning of a line. Whitespace before ':' is skipped. Whitespace and
* zeros after the ':' will be skipped. field must be freed afterwards.
* terminator specifies the terminating characters of the field value (not
* included in the value).
*/
int get_proc_field(const char *filename, const char *pattern, const char *terminator, char **field) {
_cleanup_free_ char *status = NULL;
char *t, *f;
size_t len;
int r;
assert(terminator);
assert(filename);
assert(pattern);
assert(field);
r = read_full_file(filename, &status, NULL);
if (r < 0)
return r;
t = status;
do {
bool pattern_ok;
do {
t = strstr(t, pattern);
if (!t)
return -ENOENT;
/* Check that pattern occurs in beginning of line. */
pattern_ok = (t == status || t[-1] == '\n');
t += strlen(pattern);
} while (!pattern_ok);
t += strspn(t, " \t");
if (!*t)
return -ENOENT;
} while (*t != ':');
t++;
if (*t) {
t += strspn(t, " \t");
/* Also skip zeros, because when this is used for
* capabilities, we don't want the zeros. This way the
* same capability set always maps to the same string,
* irrespective of the total capability set size. For
* other numbers it shouldn't matter. */
t += strspn(t, "0");
/* Back off one char if there's nothing but whitespace
and zeros */
if (!*t || isspace(*t))
t--;
}
len = strcspn(t, terminator);
f = strndup(t, len);
if (!f)
return -ENOMEM;
*field = f;
return 0;
}
struct ovsdb_error *
ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp)
{
uint8_t expected_sha1[SHA1_DIGEST_SIZE];
uint8_t actual_sha1[SHA1_DIGEST_SIZE];
struct ovsdb_error *error;
off_t data_offset;
unsigned long data_length;
struct json *json;
char header[128];
*jsonp = json = NULL;
if (file->read_error) {
return ovsdb_error_clone(file->read_error);
} else if (file->mode == OVSDB_LOG_WRITE) {
return OVSDB_BUG("reading file in write mode");
}
if (!fgets(header, sizeof header, file->stream)) {
if (feof(file->stream)) {
error = NULL;
} else {
error = ovsdb_io_error(errno, "%s: read failed", file->name);
}
goto error;
}
if (!parse_header(header, &data_length, expected_sha1)) {
error = ovsdb_syntax_error(NULL, NULL, "%s: parse error at offset "
"%lld in header line \"%.*s\"",
file->name, (long long int) file->offset,
(int) strcspn(header, "\n"), header);
goto error;
}
data_offset = file->offset + strlen(header);
error = parse_body(file, data_offset, data_length, actual_sha1, &json);
if (error) {
goto error;
}
if (memcmp(expected_sha1, actual_sha1, SHA1_DIGEST_SIZE)) {
error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
"offset %lld have SHA-1 hash "SHA1_FMT" "
"but should have hash "SHA1_FMT,
file->name, data_length,
(long long int) data_offset,
SHA1_ARGS(actual_sha1),
SHA1_ARGS(expected_sha1));
goto error;
}
if (json->type == JSON_STRING) {
error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
"offset %lld are not valid JSON (%s)",
file->name, data_length,
(long long int) data_offset,
json->u.string);
goto error;
}
file->prev_offset = file->offset;
file->offset = data_offset + data_length;
*jsonp = json;
return NULL;
error:
file->read_error = ovsdb_error_clone(error);
json_destroy(json);
return error;
}
int rc_read_config(char *filename)
{
FILE *configfd;
char buffer[512], *p;
OPTION *option;
int line, pos;
if ((configfd = fopen(filename,"r")) == NULL)
{
rc_log(LOG_ERR,"rc_read_config: can't open %s: %s", filename, strerror(errno));
return (-1);
}
line = 0;
while ((fgets(buffer, sizeof(buffer), configfd) != NULL))
{
line++;
p = buffer;
if ((*p == '\n') || (*p == '#') || (*p == '\0'))
continue;
p[strlen(p)-1] = '\0';
if ((pos = strcspn(p, "\t ")) == 0) {
rc_log(LOG_ERR, "%s: line %d: bogus format: %s", filename, line, p);
return (-1);
}
p[pos] = '\0';
if ((option = find_option(p, OT_ANY)) == NULL) {
rc_log(LOG_ERR, "%s: line %d: unrecognized keyword: %s", filename, line, p);
return (-1);
}
if (option->status != ST_UNDEF) {
rc_log(LOG_ERR, "%s: line %d: duplicate option line: %s", filename, line, p);
return (-1);
}
p += pos+1;
while (isspace(*p))
p++;
switch (option->type) {
case OT_STR:
if (set_option_str(filename, line, option, p) < 0)
return (-1);
break;
case OT_INT:
if (set_option_int(filename, line, option, p) < 0)
return (-1);
break;
case OT_SRV:
if (set_option_srv(filename, line, option, p) < 0)
return (-1);
break;
case OT_AUO:
if (set_option_auo(filename, line, option, p) < 0)
return (-1);
break;
default:
rc_log(LOG_CRIT, "rc_read_config: impossible case branch!");
abort();
}
}
fclose(configfd);
return test_config(filename);
}
/*
* cvs_read_rcfile()
*
* Read the CVS `.cvsrc' file in the user's home directory. If the file
* exists, it should contain a list of arguments that should always be given
* implicitly to the specified commands.
*/
static void
cvs_read_rcfile(void)
{
char rcpath[MAXPATHLEN], *buf, *lbuf, *lp, *p;
int cmd_parsed, cvs_parsed, i, linenum;
size_t len, pos;
struct cvs_cmd *tcmdp;
FILE *fp;
linenum = 0;
i = snprintf(rcpath, MAXPATHLEN, "%s/%s", cvs_homedir, CVS_PATH_RC);
if (i < 0 || i >= MAXPATHLEN) {
cvs_log(LP_ERRNO, "%s", rcpath);
return;
}
fp = fopen(rcpath, "r");
if (fp == NULL) {
if (errno != ENOENT)
cvs_log(LP_NOTICE, "failed to open `%s': %s", rcpath,
strerror(errno));
return;
}
cmd_parsed = cvs_parsed = 0;
lbuf = NULL;
while ((buf = fgetln(fp, &len)) != NULL) {
if (buf[len - 1] == '\n') {
buf[len - 1] = '\0';
} else {
lbuf = xmalloc(len + 1);
memcpy(lbuf, buf, len);
lbuf[len] = '\0';
buf = lbuf;
}
linenum++;
/* skip any whitespaces */
p = buf;
while (*p == ' ')
p++;
/*
* Allow comments.
* GNU cvs stops parsing a line if it encounters a \t
* in front of a command, stick at this behaviour for
* compatibility.
*/
if (*p == '#' || *p == '\t')
continue;
pos = strcspn(p, " \t");
if (pos == strlen(p)) {
lp = NULL;
} else {
lp = p + pos;
*lp = '\0';
}
if (strcmp(p, "cvs") == 0 && !cvs_parsed) {
/*
* Global default options. In the case of cvs only,
* we keep the 'cvs' string as first argument because
* getopt() does not like starting at index 0 for
* argument processing.
*/
if (lp != NULL) {
*lp = ' ';
cvs_defargs = xstrdup(p);
}
cvs_parsed = 1;
} else {
tcmdp = cvs_findcmd(p);
if (tcmdp == NULL && verbosity == 2)
cvs_log(LP_NOTICE,
"unknown command `%s' in `%s:%d'",
p, rcpath, linenum);
if (tcmdp != cmdp || cmd_parsed)
continue;
if (lp != NULL) {
lp++;
cmdp->cmd_defargs = xstrdup(lp);
}
cmd_parsed = 1;
}
}
if (lbuf != NULL)
xfree(lbuf);
if (ferror(fp)) {
cvs_log(LP_NOTICE, "failed to read line from `%s'", rcpath);
}
(void)fclose(fp);
}
/*
* Compare list of exclusions against an event name.
* Return a list of legal exclusion names.
* Produce an error or a warning about others (depending on the situation)
*/
static
int check_exclusion_subsets(const char *event_name,
const char *exclusions,
int *exclusion_count_ptr,
char ***exclusion_list_ptr)
{
const char *excluder_ptr;
const char *event_ptr;
const char *next_excluder;
int excluder_length;
int exclusion_count = 0;
char **exclusion_list = NULL;
int ret = CMD_SUCCESS;
if (event_name[strlen(event_name) - 1] != '*') {
ERR("Event %s: Excluders can only be used with wildcarded events", event_name);
goto error;
}
next_excluder = exclusions;
while (*next_excluder != 0) {
event_ptr = event_name;
excluder_ptr = next_excluder;
excluder_length = strcspn(next_excluder, ",");
/* Scan both the excluder and the event letter by letter */
while (1) {
char e, x;
e = *event_ptr;
x = *excluder_ptr;
if (x == '*') {
/* Event is a subset of the excluder */
ERR("Event %s: %.*s excludes all events from %s",
event_name,
excluder_length,
next_excluder,
event_name);
goto error;
}
if (e == '*') {
char *string;
char **new_exclusion_list;
/* Excluder is a proper subset of event */
string = lttng_strndup(next_excluder, excluder_length);
if (!string) {
PERROR("lttng_strndup error");
goto error;
}
new_exclusion_list = realloc(exclusion_list,
sizeof(char *) * (exclusion_count + 1));
if (!new_exclusion_list) {
PERROR("realloc");
free(string);
goto error;
}
exclusion_list = new_exclusion_list;
exclusion_count++;
exclusion_list[exclusion_count - 1] = string;
break;
}
if (x != e) {
/* Excluder and event sets have no common elements */
WARN("Event %s: %.*s does not exclude any events from %s",
event_name,
excluder_length,
next_excluder,
event_name);
break;
}
excluder_ptr++;
event_ptr++;
}
/* next excluder */
next_excluder += excluder_length;
if (*next_excluder == ',') {
next_excluder++;
}
}
goto end;
error:
while (exclusion_count--) {
free(exclusion_list[exclusion_count]);
}
if (exclusion_list != NULL) {
free(exclusion_list);
}
exclusion_list = NULL;
exclusion_count = 0;
ret = CMD_ERROR;
end:
*exclusion_count_ptr = exclusion_count;
*exclusion_list_ptr = exclusion_list;
return ret;
}
/* This should be called with the leading "!" stripped off the original
* input line.
*
* You can change this function in any way you like.
*
*/
int handle_command_input(char *line)
{
char cmd = line[0]; /* single character identifying which command */
int len = 0;
int goodlen = 0;
int result = 0;
int retries = RETRY_COUNT,
pause = RETRY_PAUSE;
line++; /* skip cmd char */
/* 1. Simple format check */
switch(cmd) {
// TODO: change name
case 'r':
case 'q':
if (strlen(line) != 0) {
printf("Error in command format: !%c should not be followed "
"by anything.\n",cmd);
return 0;
}
break;
case 'c':
case 'm':
case 's':
{
int allowed_len = MAX_ROOM_NAME_LEN;
if (line[0] != ' ') {
printf("Error in command format: !%c should be followed "
"by a space and a room name.\n",cmd);
return 0;
}
line++; /* skip space before room name */
len = strlen(line);
goodlen = strcspn(line, " \t\n"); /* Any more whitespace in line? */
if (len != goodlen) {
printf("Error in command format: line contains extra "
"whitespace (space, tab or carriage return)\n");
return 0;
}
if (len > allowed_len) {
printf("Error in command format: name must not exceed %d "
"characters.\n",allowed_len);
return 0;
}
}
break;
default:
printf("Error: unrecognized command !%c\n",cmd);
return 0;
break;
}
/* 2. Passed format checks. Handle the command */
do {
switch(cmd) {
case 'r':
result = retry_handler(handle_room_list_req, NULL,
&retries, &pause);
break;
case 'c':
result = retry_handler(handle_create_room_req, line,
&retries, &pause);
break;
case 'm':
result = retry_handler(handle_member_list_req, line,
&retries, &pause);
break;
case 's':
result = retry_handler(handle_switch_room_req, line,
&retries, &pause);
break;
case 'q':
/* exits if successfull */
result = retry_handler(handle_quit_req, NULL,
&retries, &pause);
break;
default:
printf("Error !%c is not a recognized command.\n",cmd);
break;
}
switch (result) {
/* Success, or errors that won't be helped by a resend
* or reconnection */
case COMMAND_SUCC:
case ROOM_NOT_FOUND:
case MAX_ROOMS:
case ROOM_EXISTS:
case ROOM_NAME_TOOOO_LOOOONG:
case ROOM_FULL:
case ZERO_ROOMS:
return 0;
case_RETURN /* We should return up to main and reconnect */
return result;
/*
case_RETRYABLE
retries--;
fprintf(stderr, "%s: error, retrying...\n", __func__);
sleep(pause);
break;
*/
default:
fprintf(stderr, "%s: unexpected error (%d)\n", __func__);
return result;
break;
}
} while((result != 0) && (retries > 0));
/* Error if we ran out of retries */
return (retries <= 0)? result : 0;
}
static int write_room(struct aim_chat *chat) {
char filename[65536];
char buf[MAXSNLEN+1024];
char *pork_dir = opt_get_str(OPT_PORK_DIR);
FILE *file;
dlist_t *cur;
if (pork_dir == NULL) {
sprintf(filename, ".");
opt_set(OPT_PORK_DIR, filename);
}
snprintf(filename, 65535, "%s/%s", pork_dir, chat->title);
file = fopen(filename, "wb");
if (file == NULL)
return 0;
cur = chat->downers;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "d:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->fullops;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "f:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->oparray;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "o:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->halfops;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "h:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->immlist;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "i:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->abarray;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "b:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->akarray;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "k:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
cur = chat->awarray;
while (cur != NULL) {
snprintf(buf, MAXSNLEN+3, "w:%s\n", (char*)cur->data);
fputs(buf, file);
buf[strcspn(buf, "\n")] = '\0';
screen_err_msg("%s", buf);
cur = cur->next;
}
fclose(file);
return 1;
}