コード例 #1
0
ファイル: special.c プロジェクト: Onirik79/bardmud
SPEC_RET spec_janitor( CHAR_DATA *ch )
{
	OBJ_DATA *trash;
	OBJ_DATA *trash_next;

	if ( !is_awake(ch) )
		return FALSE;

	for ( trash = ch->in_room->first_content;  trash;  trash = trash_next )
	{
		trash_next = trash->next_content;

		if ( !HAS_BIT(trash->wear_flags, OBJWEAR_TAKE) )	continue;
		if ( HAS_BIT(trash->extra_flags, OBJFLAG_BURIED) )	continue;

		if ( trash->type == OBJTYPE_DRINK_CON
		  || trash->type == OBJTYPE_TRASH
		  || trash->cost < 10
		  || (trash->pObjProto->vnum == VNUM_OBJ_SHOPPING_BAG && !trash->first_content) )
		{
			act( AT_ACTION, "$n raccoglie della spazzatura.", ch, NULL, NULL, TO_ROOM );
			obj_from_room( trash );
			obj_to_char( trash, ch );
			return TRUE;
		}
	}

	return FALSE;
}
コード例 #2
0
ファイル: main.c プロジェクト: SlySven/tintin
void abort_handler(int signal)
{
	static char crashed = FALSE;

	if (crashed)
	{
		exit(-1);
	}
	crashed = TRUE;

	restore_terminal();

	clean_screen(gtd->ses);

	dump_stack();

	fflush(NULL);

	exit(-1);

	if (gtd->ses->connect_retry > utime())
	{
		gtd->ses->connect_retry = 0;
	}
	else if (HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_SGA) && !HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO))
	{
		socket_printf(gtd->ses, 1, "%c", 3);
	}
	else
	{
		do_zap(gtd->ses, "");
	}
}
コード例 #3
0
ファイル: parse.c プロジェクト: skout23/snowy
void write_mud(struct session *ses, char *command, int flags)
{
	char output[BUFFER_SIZE];
	int size;

	size = substitute(ses, command, output, flags);

	if (HAS_BIT(ses->flags, SES_FLAG_MAPPING))
	{
		if (ses->map == NULL || ses->map->nofollow == 0)
		{
			check_insert_path(command, ses);
		}
	}

	if (ses->map && ses->map->in_room && ses->map->nofollow == 0)
	{
		if (!HAS_BIT(ses->map->flags, MAP_FLAG_NOFOLLOW))
		{
			if (follow_map(ses, command))
			{
				return;
			}
		}
	}

	write_line_mud(ses, output, size);
}
コード例 #4
0
ファイル: input.c プロジェクト: LokiChaos/tintin
void process_input(void)
{
	if (HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_SGA) && !HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO))
	{
		read_key();
	}
	else
	{
		read_line();
	}

	if (!HAS_BIT(gtd->flags, TINTIN_FLAG_PROCESSINPUT))
	{
		return;
	}

	DEL_BIT(gtd->flags, TINTIN_FLAG_PROCESSINPUT);

	if (gtd->chat && gtd->chat->paste_time)
	{
		chat_paste(gtd->input_buf, NULL);

		return;
	}

	if (HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO))
	{
		add_line_history(gtd->ses, gtd->input_buf);
	}

	if (HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO))
	{
		echo_command(gtd->ses, gtd->input_buf);
	}
	else
	{
		echo_command(gtd->ses, "");
	}

	if (gtd->ses->scroll_line != -1)
	{
		buffer_end(gtd->ses, "");
	}

	check_all_events(gtd->ses, SUB_ARG|SUB_SEC, 0, 1, "RECEIVED INPUT", gtd->input_buf);

	gtd->ses = script_driver(gtd->ses, LIST_COMMAND, gtd->input_buf);

	if (IS_SPLIT(gtd->ses))
	{
		erase_toeol();
	}

	gtd->input_buf[0] = 0;
}
コード例 #5
0
ファイル: input.c プロジェクト: LokiChaos/tintin
void echo_command(struct session *ses, char *line)
{
	char buffer[STRING_SIZE], result[STRING_SIZE];

	if (HAS_BIT(ses->flags, SES_FLAG_SPLIT))
	{
		sprintf(buffer, "%s%s\033[0m", ses->cmd_color, line);
	}
	else
	{
		sprintf(buffer, "%s", line);
	}

	/*
		Deal with pending output
	*/

	if (ses->more_output[0])
	{
		if (ses->check_output)
		{
			strcpy(result, ses->more_output);
			ses->more_output[0] = 0;

			process_mud_output(ses, result, FALSE);
		}
	}

	DEL_BIT(ses->telopts, TELOPT_FLAG_PROMPT);

	if (HAS_BIT(ses->flags, SES_FLAG_SPLIT))
	{
		if (!HAS_BIT(ses->flags, SES_FLAG_ECHOCOMMAND))
		{
			sprintf(result, "\033[0;37m");
		}
		else
		{
			sprintf(result, "%s%s", ses->more_output, buffer);
		}
		add_line_buffer(ses, buffer, -1);

		SET_BIT(ses->flags, SES_FLAG_SCROLLSTOP);

		tintin_printf2(ses, "%s", result);

		DEL_BIT(ses->flags, SES_FLAG_SCROLLSTOP);
	}
	else
	{
		add_line_buffer(ses, buffer, -1);
	}
}
コード例 #6
0
void modified_input(void) {
  kill_list(gtd->ses->list[LIST_TABCYCLE]);

  if (HAS_BIT(gtd->flags, TINTIN_FLAG_HISTORYSEARCH)) {
    cursor_history_find("");
  }

  if (HAS_BIT(gtd->flags, TINTIN_FLAG_HISTORYBROWSE)) {
    DEL_BIT(gtd->flags, TINTIN_FLAG_HISTORYBROWSE);
  }

}
コード例 #7
0
ファイル: parse.c プロジェクト: skout23/snowy
char *get_arg_stop_spaces(struct session *ses, char *string, char *result, int flag)
{
	char *pto, *pti;
	int nest = 0;

	pti = space_out(string);
	pto = result;

	while (*pti)
	{
		if (HAS_BIT(ses->flags, SES_FLAG_BIG5) && *pti & 128 && pti[1] != 0)
		{
			*pto++ = *pti++;
			*pto++ = *pti++;
			continue;
		}

		if (*pti == '\\' && pti[1] == COMMAND_SEPARATOR)
		{
			*pto++ = *pti++;
		}
		else if (*pti == COMMAND_SEPARATOR && nest == 0)
		{
			break;
		}
		else if (isspace((int) *pti) && nest == 0)
		{
			pti++;
			break;
		}
		else if (*pti == DEFAULT_OPEN)
		{
			nest++;
		}
		else if (*pti == '[' && HAS_BIT(flag, GET_NST))
		{
			nest++;
		}
		else if (*pti == DEFAULT_CLOSE)
		{
			nest--;
		}
		else if (*pti == ']' && HAS_BIT(flag, GET_NST))
		{
			nest--;
		}
		*pto++ = *pti++;
	}
	*pto = '\0';

	return pti;
}
コード例 #8
0
ファイル: text.c プロジェクト: LokiChaos/tintin
void printline(struct session *ses, char **str, int prompt)
{
	char *out;

	push_call("printline(%p,%p,%d)",ses,*str,prompt);

	if (ses->scroll_line != -1 && HAS_BIT(ses->flags, SES_FLAG_SCROLLLOCK))
	{
		pop_call();
		return;
	}

	if (HAS_BIT(ses->flags, SES_FLAG_SCAN) && !HAS_BIT(ses->flags, SES_FLAG_VERBOSE))
	{
		pop_call();
		return;
	}

	out = str_alloc(strlen(*str) * 2);

	if (HAS_BIT(ses->flags, SES_FLAG_CONVERTMETA))
	{
		convert_meta(*str, out);
		str_cpy(str, out);
	}

	if (HAS_BIT(ses->flags, SES_FLAG_WORDWRAP))
	{
		word_wrap(ses, *str, out, TRUE);
	}
	else
	{
		strcpy(out, *str);
	}

	if (prompt)
	{
		printf("%s", out);
	}
	else
	{
		printf("%s\n", out);
	}

	str_free(out);

	pop_call();
	return;
}
コード例 #9
0
void process_mud_output(struct session *ses, char *linebuf, int prompt) {
  char line[STRING_SIZE];

  ses->check_output = 0;

  strip_vt102_codes(linebuf, line);

  check_all_events(ses, SUB_ARG | SUB_SEC, 0, 2, "RECEIVED LINE", linebuf, line);

  if (prompt) {
    check_all_events(ses, SUB_ARG | SUB_SEC, 0, 2, "RECEIVED PROMPT", linebuf, line);
  }

  if (HAS_BIT(ses->flags, SES_FLAG_COLORPATCH)) {
    sprintf(line, "%s%s", ses->color, linebuf);

    get_color_codes(ses->color, linebuf, ses->color);

    linebuf = line;
  }

  do_one_line(linebuf, ses);    /* changes linebuf */

  /*
     Take care of gags, vt102 support still goes
   */

  if (HAS_BIT(ses->flags, SES_FLAG_GAG)) {
    strip_non_vt102_codes(linebuf, ses->more_output);

    printf("%s", ses->more_output);

    ses->more_output[0] = 0;

    DEL_BIT(ses->flags, SES_FLAG_GAG);

    return;
  }

  add_line_buffer(ses, linebuf, prompt);

  if (ses == gtd->ses) {
    printline(ses, linebuf, prompt);
  } else if (HAS_BIT(ses->flags, SES_FLAG_SNOOP)) {
    strip_vt102_codes_non_graph(linebuf, linebuf);

    tintin_printf2(gtd->ses, "[%s] %s", ses->name, linebuf);
  }
}
コード例 #10
0
ファイル: main.c プロジェクト: LokiChaos/tintin
void interrupt_handler(int signal)
{
	if (gtd->ses->connect_retry > utime())
	{
		gtd->ses->connect_retry = 0;
	}
	else if (HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_SGA) && !HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO))
	{
		socket_printf(gtd->ses, 1, "%c", 4);
	}
	else
	{
		cursor_delete_or_exit(gtd->ses, "");
	}
}
コード例 #11
0
int inputline_raw_str_len(int start, int end) {
  int raw_cnt, ret_cnt;

  raw_cnt = start;
  ret_cnt = 0;

  while (raw_cnt < gtd->input_len) {
    if (raw_cnt >= end) {
      break;
    }

    if (HAS_BIT(gtd->ses->flags, SES_FLAG_UTF8)
        && (gtd->input_buf[raw_cnt] & 192) == 192) {
      raw_cnt++;

      while (raw_cnt < gtd->input_len && (gtd->input_buf[raw_cnt] & 192) == 128) {
        raw_cnt++;
      }
    } else {
      raw_cnt++;
    }
    ret_cnt++;
  }
  return ret_cnt;
}
コード例 #12
0
ファイル: parse.c プロジェクト: tintinplusplus/tintin
char *get_arg_to_brackets(struct session *ses, char *string, char *result)
{
	char *pti, *pto, *ptii, *ptoo;
	int nest1 = 0, nest2 = 0, nest3 = 0;

	pti = space_out(string);
	pto = result;
	ptii = ptoo = NULL;

	while (*pti)
	{
		if (HAS_BIT(ses->flags, SES_FLAG_BIG5) && *pti & 128 && pti[1] != 0)
		{
			*pto++ = *pti++;
			*pto++ = *pti++;
			continue;
		}

		if (*pti == '[')
		{
			nest2++;

			if (nest1 == 0 && ptii == NULL)
			{
				ptii = pti;
				ptoo = pto;
			}
		}
		else if (*pti == ']')
		{
			if (nest2)
			{
				nest2--;
			}
			else
			{
				nest3 = 1;
			}

			if (*(pti+1) == 0 && ptii && nest1 == 0 && nest2 == 0 && nest3 == 0)
			{
				*ptoo = 0;

				return ptii;
			}
		}
		else if (*pti == DEFAULT_OPEN)
		{
			nest1++;
		}
		else if (*pti == DEFAULT_CLOSE)
		{
			nest1--;
		}
		*pto++ = *pti++;
	}
	*pto = 0;

	return pti;
}
コード例 #13
0
ファイル: history.c プロジェクト: SlySven/tintin
void add_line_history(struct session *ses, char *line)
{
	struct listroot *root;

	root = ses->list[LIST_HISTORY];

	if (*line == 0)
	{
		if (root->used && HAS_BIT(ses->flags, SES_FLAG_REPEATENTER))
		{
			strcpy(line, root->list[root->used - 1]->left);
		}
		return;
	}

	if (*line == gtd->repeat_char)
	{
		search_line_history(ses, line);
	}

	update_node_list(ses->list[LIST_HISTORY], line, "", "");

	while (root->used > gtd->history_size)
	{
		delete_index_list(ses->list[LIST_HISTORY], 0);
	}

	return;
}
コード例 #14
0
ファイル: vt102.c プロジェクト: LokiChaos/tintin
int strip_vt102_strlen(struct session *ses, char *str)
{
	char *pti;
	int i = 0;

	pti = str;

	while (*pti)
	{
		if (skip_vt102_codes(pti))
		{
			pti += skip_vt102_codes(pti);

			continue;
		}

		if (HAS_BIT(ses->flags, SES_FLAG_UTF8) && (*pti & 192) == 192)
		{
			pti++;

			while ((*pti & 192) == 128)
			{
				pti++;
			}
		}
		else
		{
			pti++;
		}
		i++;
	}
	return i;
}
コード例 #15
0
ファイル: main.c プロジェクト: SlySven/tintin
void winch_handler(int signal)
{
	struct session *ses;

	init_screen_size(gts);

	for (ses = gts->next ; ses ; ses = ses->next)
	{
		init_screen_size(ses);

		if (HAS_BIT(ses->telopts, TELOPT_FLAG_NAWS))
		{
			send_sb_naws(ses, 0, NULL);
		}
	}

	/*
		we have to reinitialize the signals for sysv machines

	if (signal(SIGWINCH, winch_handler) == BADSIG)
	{
		syserr("signal SIGWINCH");
	}
	*/
}
コード例 #16
0
ファイル: tinexp.c プロジェクト: skout23/snowy
int check_one_regexp(struct session *ses, struct listnode *node, char *line, char *original, int option)
{
	char *exp, *str;

	if (node->regex == NULL)
	{
		char result[BUFFER_SIZE];

		substitute(ses, node->left, result, SUB_VAR|SUB_FUN);

		exp = result;
	}
	else
	{
		exp = node->left;
	}

	if (HAS_BIT(node->flags, NODE_FLAG_META))
	{
		exp++;
		str = original;
	}
	else
	{
		str = line;
	}	

	return tintin_regexp(ses, node->regex, str, exp, option, SUB_ARG);
}
コード例 #17
0
ファイル: SftpExt.c プロジェクト: Orea1234/mysecureshell
void DoExtDiskSpace(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
	struct STATFS stfs;
	tFSPath	*realPath;
	char *path;

	path = convertFromUtf8(BufferGetString(bIn), 1);
	realPath = FSCheckPath(path);
	DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Path: %s", path));
	if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))
	{
		DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Realpath: %s", realPath->realPath));
		if (STATFS(realPath->realPath, &stfs) == 0)
		{
			tBuffer *b;

			b = BufferNew();
			BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);
			BufferPutInt32(b, id);
			BufferPutInt64(b, (u_int64_t) stfs.f_blocks * (u_int64_t) stfs.f_bsize);
			BufferPutInt64(b, (u_int64_t) stfs.f_bfree * (u_int64_t) stfs.f_bsize);
			BufferPutInt64(b, 0);
			BufferPutInt64(b, (u_int64_t) stfs.f_bavail * (u_int64_t) stfs.f_bsize);
			BufferPutInt32(b, stfs.f_bsize);
			BufferPutPacket(bOut, b);
		}
		else
			SendStatus(bOut, id, errnoToPortable(errno));
	}
	else
		SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);
	FSDestroyPath(realPath);
	free(path);
}
コード例 #18
0
ファイル: session.c プロジェクト: SlySven/tintin
void show_session(struct session *ses, struct session *ptr)
{
	char temp[BUFFER_SIZE];

	sprintf(temp, "%3d %-12s %20s:%-5s", ptr->socket, ptr->name, ptr->host, ptr->port);

	if (ptr == gtd->ses)
	{
		strcat(temp, " (active)");
	}
	else
	{
		strcat(temp, "         ");
	}

	if (ptr->mccp)
	{
		strcat(temp, " (mccp)   ");
	}

	if (HAS_BIT(ptr->flags, SES_FLAG_SNOOP))
	{
		strcat(temp, " (snooped)");
	}

	if (ptr->logfile)
	{
		strcat(temp, " (logging)");
	}

	tintin_puts2(ses, temp);
}
コード例 #19
0
ファイル: parse.c プロジェクト: skout23/snowy
char *get_arg_to_brackets(struct session *ses, char *string, char *result)
{
	char *pti, *pto;

	pti = space_out(string);
	pto = result;

	while (*pti)
	{
		if (HAS_BIT(ses->flags, SES_FLAG_BIG5) && *pti & 128 && pti[1] != 0)
		{
			*pto++ = *pti++;
			*pto++ = *pti++;
			continue;
		}

		if (*pti == '[')
		{
			break;
		}
		*pto++ = *pti++;
	}
	*pto = 0;

	return pti;
}
コード例 #20
0
ファイル: prompt.c プロジェクト: SlySven/tintin
void check_all_prompts(struct session *ses, char *original, char *line)
{
	struct listroot *root = ses->list[LIST_PROMPT];
	struct listnode *node;

	if (!HAS_BIT(ses->flags, SES_FLAG_SPLIT))
	{
		return;
	}

	for (root->update = 0 ; root->update < root->used ; root->update++)
	{
		if (check_one_regexp(ses, root->list[root->update], line, original, 0))
		{
			node = root->list[root->update];

			if (*node->right)
			{
				substitute(ses, node->right, original, SUB_ARG);
				substitute(ses, original, original, SUB_VAR|SUB_FUN|SUB_COL|SUB_ESC);
			}

			show_debug(ses, LIST_PROMPT, "#DEBUG PROMPT {%s}", node->left);

			do_one_prompt(ses, original, atoi(node->pr));

			SET_BIT(ses->flags, SES_FLAG_GAG);
		}
	}
}
コード例 #21
0
ファイル: special.c プロジェクト: Onirik79/bardmud
/*
 * Se un mob conosce la magia e odia qualcuno allora prova a evocarlo.
 */
void summon_if_hating( CHAR_DATA *ch )
{
	CHAR_DATA *victim;
	char	   buf[MSL];
	char	   name[MIL];
	bool	   found = FALSE;

	if ( ch->position <= POSITION_SLEEP )			return;
	if ( ch->fighting ) 							return;
	if ( ch->fearing )								return;
	if ( !ch->hating )								return;
	if ( HAS_BIT(ch->in_room->flags, ROOM_SAFE) )	return;
	if ( ch->hunting )								return;	/* Non evoca se un pg è vicino abbastanza da poterlo cacciare */

	one_argument( ch->hating->name, name );

	/* Si assicura che il giocatore esista, funziona anche se il pg esce dal gioco */
	for ( victim = first_char;  victim;  victim = victim->next )
	{
		if ( !str_cmp(victim->name, ch->hating->name) )
		{
			found = TRUE;
			break;
		}
	}

	if ( !found )
		return;

	if ( victim->in_room == ch->in_room )
		return;

	sprintf( buf, "cast summon %s", name );
	send_command( ch, buf, CO );
}
コード例 #22
0
ファイル: olc_redit.c プロジェクト: Onirik79/bardmud
/* For exit flags */
void redit_disp_exit_flag_menu( DESCRIPTOR_DATA *d )
{
	EXIT_DATA		   *pexit = d->character->spare_ptr;
	char				buf[MSL];
	int					x;

	write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 );

	for ( x = 0;  x < MAX_EXIT;  x++ )
	{
		if ( (x == EXIT_RES1) || (x == EXIT_RES2) || (x == EXIT_PORTAL) )
			continue;
		ch_printf( d->character, "&g%2d&w) %-20.20s\r\n", x+1, code_name(NULL, x, CODE_EXIT) );
	}

	buf[0] = '\0';
	for ( x = 0;  x < MAX_EXIT;  x++ )
	{
		if ( HAS_BIT(pexit->flags, x) )
		{
			strcat( buf, code_name(NULL, x, CODE_EXIT) );
			strcat( buf, " " );
		}
	}

	ch_printf( d->character, "\r\nExit flags: &c%s&w\r\n"
		"Enter room flags, 0 to quit: ", buf );
	OLC_MODE(d) = REDIT_EXIT_FLAGS;
}
コード例 #23
0
ファイル: olc_redit.c プロジェクト: Onirik79/bardmud
void redit_disp_exit_edit( DESCRIPTOR_DATA *d )
{
	char				flags[MSL];
	EXIT_DATA		   *pexit = d->character->spare_ptr;
	int					x;

	flags[0] = '\0';
	for ( x = 0;  x < MAX_EXIT;  x++ )
	{
		if ( pexit->flags && HAS_BIT(pexit->flags, x) )
		{
			strcat( flags, code_name(NULL, x, CODE_EXIT) );
			strcat( flags, " " );
		}
	}

	OLC_MODE(d) = REDIT_EXIT_EDIT;
	write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 );

	ch_printf( d->character, "&g1&w) Direction  : &c%s\r\n",	code_name(NULL, pexit->vdir, CODE_DIR) );
	ch_printf( d->character, "&g2&w) To Vnum	: &c%d\r\n",	(pexit->to_room)  ?  pexit->to_room->vnum  :  -1 );
	ch_printf( d->character, "&g3&w) Key		: &c%d\r\n",	pexit->key );
	ch_printf( d->character, "&g4&w) Keyword	: &c%s\r\n",	(VALID_STR(pexit->keyword))  ?  pexit->keyword  :  "(none)" );
	ch_printf( d->character, "&g5&w) Flags      : &c%s\r\n",	(VALID_STR(flags))  ?  flags  :  "(none)" );
	ch_printf( d->character, "&g6&w) Description: &c%s\r\n",	(VALID_STR(pexit->description))  ?  pexit->description  :  "(none)" );
	send_to_char( d->character, "&gQ&w) Quit\r\n" );
	send_to_char( d->character, "\r\nEnter choice: " );
}
コード例 #24
0
ファイル: special.c プロジェクト: Onirik79/bardmud
SPEC_RET spec_executioner( CHAR_DATA *ch )
{
	MOB_PROTO_DATA *cityguard;
	CHAR_DATA	   *victim;
	CHAR_DATA	   *v_next;
	char		   *crime;
	char			buf[MSL];

	if ( !is_awake(ch) )	return FALSE;
	if ( ch->fighting )		return FALSE;

	crime = "";
	for ( victim = ch->in_room->first_person;  victim;  victim = v_next )
	{
		v_next = victim->next_in_room;

		if ( IS_PG(victim) && HAS_BIT_PLR(victim, PLAYER_KILLER) )
		{
			crime = "assassino";
			break;
		}

		if ( IS_PG(victim) && HAS_BIT_PLR(victim, PLAYER_THIEF) )
		{
			crime = "ladro";
			break;
		}
	}

	if ( !victim )
		return FALSE;

	if ( HAS_BIT(ch->in_room->flags, ROOM_SAFE) )
	{
		sprintf( buf, "yell codardo di un %s!", crime );	/* (GR) articolo */
		send_command( ch, buf, CO );
		return TRUE;
	}

	sprintf( buf, "yell Proteggiamo l'innocente dal %s!!", crime );	/* (GR) articolo dal dall' */
	send_command( ch, buf, CO );
	multi_hit( ch, victim, TYPE_UNDEFINED );

	if ( char_died(ch) )
		return TRUE;

	/* Aggiunto il log nel caso che venga a mancare la guardia cittadina */
	cityguard = get_mob_index( NULL, VNUM_MOB_CITYGUARD );

	if ( !cityguard )
	{
		send_log( NULL, LOG_BUG, "spec_executioner: Guardia cittadina mancante - Vnum:[%d]", VNUM_MOB_CITYGUARD );
		return TRUE;
	}

	char_to_room( make_mobile(cityguard), ch->in_room );
	char_to_room( make_mobile(cityguard), ch->in_room );
	return TRUE;
}
コード例 #25
0
void input_printf(char *format, ...) {
  char buf[STRING_SIZE];
  va_list args;

  if (!HAS_BIT(gtd->flags, TINTIN_FLAG_HISTORYSEARCH)) {
    if (!HAS_BIT(gtd->ses->telopts, TELOPT_FLAG_ECHO)
        && gtd->input_buf[0] != gtd->tintin_char) {
      return;
    }
  }

  va_start(args, format);
  vsprintf(buf, format, args);
  va_end(args);

  printf("%s", buf);
}
コード例 #26
0
int tintin_regexp_check(struct session *ses, char *exp) {
  if (*exp == '^') {
    return TRUE;
  }

  while (*exp) {

    if (HAS_BIT(ses->flags, SES_FLAG_BIG5) && *exp & 128 && exp[1] != 0) {
      exp += 2;
      continue;
    }

    switch (exp[0]) {
      case '\\':
      case '{':
        return TRUE;

      case '$':
        if (exp[1] == 0) {
          return TRUE;
        }
        break;

      case '%':
        switch (exp[1]) {
          case '0':
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7':
          case '8':
          case '9':
          case 'd':
          case 'D':
          case 'i':
          case 'I':
          case 's':
          case 'S':
          case 'w':
          case 'W':
          case '?':
          case '*':
          case '+':
          case '.':
          case '%':
            return TRUE;
        }
        break;
    }
    exp++;
  }
  return FALSE;
}
コード例 #27
0
int inputline_str_chk(int offset, int totlen) {
  while (offset < totlen) {
    if (HAS_BIT(gtd->ses->flags, SES_FLAG_BIG5)) {
      if (gtd->input_buf[offset] & 128) {
        if (offset + 1 < totlen || gtd->input_buf[offset + 1] == 0) {
          return FALSE;
        }
        offset += 2;
      } else {
        offset += 1;
      }
    } else if (HAS_BIT(gtd->ses->flags, SES_FLAG_UTF8)) {
      switch (gtd->input_buf[offset] & (128 + 64 + 32 + 16)) {
        case 128 + 64:
        case 128 + 64 + 16:
          if (offset + 1 < totlen || (gtd->input_buf[offset + 1] & 192) != 128) {
            return FALSE;
          }
          offset += 2;
          break;

        case 128 + 64 + 32:
          if (offset + 2 < totlen || (gtd->input_buf[offset + 1] & 192) != 128 || (gtd->input_buf[offset + 2] & 192) != 128) {
            return FALSE;
          }
          offset += 3;
          break;

        case 128 + 64 + 32 + 16:
          if (offset + 3 < totlen || (gtd->input_buf[offset + 1] & 192) != 128 || (gtd->input_buf[offset + 2] & 192) != 128 || (gtd->input_buf[offset + 3] & 192) != 128) {
            return FALSE;
          }
          offset += 4;
          break;

        default:
          offset += 1;
          break;
      }
    }
  }
  return TRUE;
}
コード例 #28
0
ファイル: Util.c プロジェクト: Orea1234/mysecureshell
int FlagsFromAccess(int access)
{
	int flags = 0;

	if (HAS_BIT(access, SSH5_ACE4_READ_DATA))
	{
		if (HAS_BIT(access, SSH5_ACE4_WRITE_DATA))
			flags = O_RDWR;
		else
			flags = O_RDONLY;
	}
	else if (HAS_BIT(access, SSH5_ACE4_WRITE_DATA))
		flags = O_WRONLY;
	if (HAS_BIT(access, SSH5_ACE4_APPEND_DATA))
		flags |= O_APPEND;
	if (HAS_BIT(access, SSH5_ACE4_SYNCHRONIZE))
		flags |= O_SYNC;
	return (flags);
}
コード例 #29
0
int check_all_aliases(struct session *ses, char *input) {
  struct listnode *node;
  struct listroot *root;
  char line[BUFFER_SIZE], tmp[BUFFER_SIZE], *arg;
  int i;

  root = ses->list[LIST_ALIAS];

  if (HAS_BIT(root->flags, LIST_FLAG_IGNORE)) {
    return FALSE;
  }

  for (i = 1; i < 100; i++) {
    if (*gtd->vars[i]) {
      RESTRING(gtd->vars[i], "");
    }
  }

  substitute(ses, input, line, SUB_VAR | SUB_FUN);

  for (root->update = 0; root->update < root->used; root->update++) {
    if (check_one_regexp(ses, root->list[root->update], line, line, PCRE_ANCHORED)) {
      node = root->list[root->update];

      i = strlen(node->left);

      if (!strncmp(node->left, line, i)) {
        if (line[i] && line[i] != ' ') {
          continue;
        }

        arg = get_arg_in_braces(ses, line, tmp, FALSE);

        RESTRING(gtd->vars[0], arg) for (i = 1; i < 100 && *arg; i++) {
          arg = get_arg_in_braces(ses, arg, tmp, FALSE);

          RESTRING(gtd->vars[i], tmp);
        }
      }

      substitute(ses, node->right, tmp, SUB_ARG);

      if (!strncmp(node->left, line, strlen(node->left))
          && !strcmp(node->right, tmp) && *gtd->vars[0]) {
        sprintf(input, "%s %s", tmp, gtd->vars[0]);
      } else {
        sprintf(input, "%s", tmp);
      }

      show_debug(ses, LIST_ALIAS, "#DEBUG ALIAS {%s} {%s}", node->left, gtd->vars[0]);

      return TRUE;
    }
  }
コード例 #30
0
ファイル: parse.c プロジェクト: skout23/snowy
char *get_arg_in_brackets(struct session *ses, char *string, char *result)
{
	char *pti, *pto;
	int nest = 1;

	pti = string;
	pto = result;

	if (*pti != '[')
	{
		*pto = 0;

		return pti;
	}

	pti++;

	while (*pti)
	{
		if (HAS_BIT(ses->flags, SES_FLAG_BIG5) && *pti & 128 && pti[1] != 0)
		{
			*pto++ = *pti++;
			*pto++ = *pti++;
			continue;
		}

		if (*pti == '[')
		{
			nest++;
		}
		else if (*pti == ']')
		{
			nest--;

			if (nest == 0)
			{
				break;
			}
		}
		*pto++ = *pti++;
	}

	if (*pti == 0)
	{
		tintin_printf2(NULL, "#UNMATCHED IN BRACKETS ERROR.");
	}
	else
	{
		pti++;
	}
	*pto = 0;

	return pti;
}