string dialogText::getResponse(string text)
{
static int index=0;
if(text == ""){
return string("不好意思，我没有听清楚你说的话^startTag(not know)，您可以再说一遍么？");
}
string cmd = "sh ../testdialog/dialog.sh ";
string text_res = exec_shell(cmd+text);
std::cout << exec_shell("pwd");
//char* expr = "animations/Stand/BodyTalk/BodyTalk_";
char* expr = "animations/Stand/Gestures/Explain_";
char buffer[200];
sprintf(buffer, "^start(%s%d)%s", expr, index%12, text_res.c_str());
index++;
std::string result(buffer);
std::string loc = "num";
std::string yuan_loc = "元";
std::string hour_loc = "小时";
std::string min_loc = "分钟";
int ind_e = result.find(loc);
int ind_yuan = result.find(yuan_loc);
int ind_hour = result.find(hour_loc);
int ind_min = result.find(min_loc);
if(ind_e == -1){
return result;
}
else{
if(ind_yuan != -1){
return result.replace(ind_e, 3, "24");
}
if(ind_hour != -1){
return result.replace(ind_e, 3, "1");
}
if(ind_min != -1){
return result.replace(ind_e, 3, "30");
}
}
}
int main(int argc, char **argv, char **env)
{
if (argc > 1)
argv++;
ft_saveenv(env);
ft_initsignal();
while (1)
exec_shell(env);
return (0);
}
/* npflush is called for filter ops effected with temp files */
void
npflush(void)
{
char buf[NFILEN + 128];
int rc, term_status;
/*
* caller has filled and closed the write pipe data stream. time to
* exec a process.
*/
if ((stdout_fd = open(stdout_name, O_RDONLY|O_BINARY)) == BAD_FD)
{
/* oh my, put complaint in user's face. */
sprintf(buf, "[unable to open temp file \"%s\": %s]",
stdout_name,
strerror(errno));
lastditch_msg(buf);
}
else
{
/* handles[1-2] were initialized by tmp_npopen_open() */
handles[0] = (HANDLE) _get_osfhandle(stdout_fd);
rc = (exec_shell(shcmd,
handles,
TRUE /* do hide child window */
) == BAD_PROC_HANDLE) ? FALSE : TRUE;
if (! rc)
{
/* Shell process failed, put complaint in user's face. */
sprintf(buf, SHELL_ERR_MSG, get_shell());
lastditch_msg(buf);
}
else
{
/* now wait for app to exit */
(void) cwait(&term_status, (CWAIT_PARAM_TYPE) proc_handle, 0);
TRACE(("...CreateProcess finished waiting in npflush\n"));
close_proc_handle();
}
/*
* When closing descriptors shared between parent and child, order
* is quite important when $shell == command.com . In this
* situation, the descriptors can't be closed until the exec'd
* process exits.
*/
close_fd(stdout_fd);
}
}
static void determineExt()
{
int chars;
// exec_shell("/bin/df -T | /bin/grep '^/dev'");
chars = exec_shell("/bin/df -T | /bin/grep 'ext4'");
DPRINT1(2,"determineExt() returned chars: %d\n",chars);
DPRINT1(2,"Ext4: %d \n",Ext4);
// if no charaters return and Ext4 has not been set then no ext4 were found in grep
// thus it is not Ext4
if ((Ext4 == -1) && (chars == 0))
Ext4 = 0;
return;
}
string tulingModule::getResponse(string text)
{
static int index=0;
if(text == ""){
return string("不好意思，我没有听清楚你说的话^startTag(not know)，您可以再说一遍么？");
}
string cmd = "curl -G http://www.tuling123.com/openapi/api -d key=c237b459589ef904699807b7dadcc300 -d info="+text+"/";
string result = exec_shell(cmd);
string rec_result;
qiLogInfo("Result From Tuling:")<<result<<std::endl;
std::string loc = "\"text\"";
int ind_e = result.find(loc);
while(result[ind_e] != ':'){
ind_e++;
}
while(result[ind_e] != '"'){
if(result[ind_e] == '}'){
rec_result = "";
return rec_result;
}
ind_e++;
}
int ind_s = ++ind_e;
while(result[ind_e] != '"'){
ind_e++;
}
rec_result = result.substr(ind_s, ind_e-ind_s);
//char* expr = "animations/Stand/BodyTalk/BodyTalk_";
char* expr = "animations/Stand/Gestures/Explain_";
char buffer[2000];
sprintf(buffer, "^start(%s%d)%s", expr, index%12, rec_result.c_str());
index++;
qiLogInfo("Result From Tuling:")<<string(buffer)<<std::endl;
return string(buffer);
}
int main() {
/* initialize the font */
font_init();
/* initialize timer */
timer_init();
/* allocate a window */
win = window_alloc("Qonsole", /* title */
font_width*80, /* width */
font_height*25, /* height */
-1, /* x (random) */
-1, /* y (random) */
0xFF000000, /* bg color */
"/usr/share/icons/qonsole16.png" /* iconfile */);
/* initialize window event handlers */
win->press = pstty_press;
/* initialize pstty */
pstty_init();
/* execute the shell */
exec_shell("/bin/rash");
/* set receiver */
set_receiver(pstty_event);
/* loop */
gui_loop();
/* done */
return 0;
}
void
sud_process(struct conf *cfp, int fd, int pipefd) {
#if defined(HAVE_GETPEEREID) || defined(SO_PEERCRED)
uid_t euid;
gid_t egid;
#endif
#if defined(HAVE_GETPEEREID)
if (getpeereid(fd, &euid, &egid) < 0) {
syslog(LOG_ERR, "getpeereid failed: %m");
if (cfp->haveauthgroup)
_exit(1);
}
#endif
#if defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
struct ucred peercred;
#ifdef HAVE_SOCKLEN_T
socklen_t olen = sizeof(struct ucred);
#else
int olen = sizeof(struct ucred);
#endif
if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &peercred, &olen) < 0) {
syslog(LOG_ERR, "can't get credential via SO_PEERCRED");
if (cfp->haveauthgroup)
_exit(1);
}
euid = peercred.uid;
egid = peercred.gid;
#endif
#if defined(HAVE_GETPEEREID) || defined(SO_PEERCRED)
/*
* XXX: LOG_INFO should be LOG_AUTH
*/
if (cfp->haveauthgroup && is_group(euid, cfp->authgroup) != 1) {
syslog(LOG_INFO, "[%s] auth failed u: %s [%lu] g: %s [%lu]",
cfp->session, get_pwentry(euid)->pw_name,
(unsigned long)euid, get_group(egid)->gr_name,
(unsigned long)egid);
_exit(1);
}
if (cfp->log)
syslog(LOG_INFO,"[%s] auth req u: %s [%lu] g: %s [%lu]",
cfp->session, get_pwentry(euid)->pw_name,
(unsigned long)euid, get_group(egid)->gr_name,
(unsigned long)egid);
set_id(cfp->havesetuser, cfp->setuser, euid);
set_id(cfp->haveseteuser, cfp->seteuser, euid);
set_id(cfp->havesetgroup, cfp->setgroup, egid);
set_id(cfp->havesetegroup, cfp->setegroup, egid);
#endif
if (cfp->terminal)
(void)setenv("TERM", cfp->terminal, 1);
else
(void)setenv("TERM", default_term ? default_term : "vt100",
default_term ? 1 : 0);
switch (cfp->mode) {
case INTERACTIVE:
exec_shell(cfp, fd, pipefd);
break;
case READ:
case BLIND:
case READWRITE:
exec_command(cfp, fd, pipefd);
break;
}
_exit(1);
}
/* Many execution paths may lead to this code so it needs to take appropriate
* precausions to stuff like doc_view and doc_view->vs being NULL. */
enum frame_event_status
do_action(struct session *ses, enum main_action action_id, int verbose)
{
enum frame_event_status status = FRAME_EVENT_OK;
struct terminal *term = ses->tab->term;
struct document_view *doc_view = current_frame(ses);
struct link *link = NULL;
if (action_id == -1) goto unknown_action;
if (doc_view && doc_view->vs) {
if (action_prefix_is_link_number(KEYMAP_MAIN, action_id)
&& !try_jump_to_link_number(ses, doc_view))
goto ignore_action;
link = get_current_link(doc_view);
} else if (action_requires_view_state(KEYMAP_MAIN, action_id)) {
goto ignore_action;
}
if (action_requires_location(KEYMAP_MAIN, action_id)
&& !have_location(ses))
return FRAME_EVENT_OK;
if (action_requires_link(KEYMAP_MAIN, action_id)
&& !link)
goto ignore_action;
if (action_requires_form(KEYMAP_MAIN, action_id)
&& (!link || !link_is_form(link)))
goto ignore_action;
if (!action_is_anonymous_safe(KEYMAP_MAIN, action_id)
&& get_cmd_opt_bool("anonymous"))
goto ignore_action;
/* Please keep in alphabetical order for now. Later we can sort by most
* used or something. */
switch (action_id) {
case ACT_MAIN_ABORT_CONNECTION:
abort_loading(ses, 1);
print_screen_status(ses);
break;
case ACT_MAIN_ADD_BOOKMARK:
#ifdef CONFIG_BOOKMARKS
launch_bm_add_doc_dialog(term, NULL, ses);
#endif
break;
case ACT_MAIN_ADD_BOOKMARK_LINK:
#ifdef CONFIG_BOOKMARKS
launch_bm_add_link_dialog(term, NULL, ses);
#endif
break;
case ACT_MAIN_ADD_BOOKMARK_TABS:
#ifdef CONFIG_BOOKMARKS
bookmark_terminal_tabs_dialog(term);
#endif
break;
case ACT_MAIN_AUTH_MANAGER:
auth_manager(ses);
break;
case ACT_MAIN_BACKSPACE_PREFIX:
if (!ses->kbdprefix.repeat_count) break;
set_kbd_repeat_count(ses,
ses->kbdprefix.repeat_count / 10);
/* Keep send_event from resetting repeat_count. */
status = FRAME_EVENT_SESSION_DESTROYED;
break;
case ACT_MAIN_BOOKMARK_MANAGER:
#ifdef CONFIG_BOOKMARKS
bookmark_manager(ses);
#endif
break;
case ACT_MAIN_CACHE_MANAGER:
cache_manager(ses);
break;
case ACT_MAIN_CACHE_MINIMIZE:
shrink_memory(1);
break;
case ACT_MAIN_COOKIES_LOAD:
#ifdef CONFIG_COOKIES
if (!get_opt_bool("cookies.save", NULL)) break;
load_cookies();
#endif
break;
case ACT_MAIN_COOKIE_MANAGER:
#ifdef CONFIG_COOKIES
cookie_manager(ses);
#endif
break;
case ACT_MAIN_COPY_CLIPBOARD:
status = copy_current_link_to_clipboard(ses, doc_view, 0);
break;
case ACT_MAIN_DOCUMENT_INFO:
document_info_dialog(ses);
break;
case ACT_MAIN_DOWNLOAD_MANAGER:
download_manager(ses);
break;
case ACT_MAIN_EXMODE:
#ifdef CONFIG_EXMODE
exmode_start(ses);
#endif
break;
case ACT_MAIN_FILE_MENU:
activate_bfu_technology(ses, 0);
break;
case ACT_MAIN_FIND_NEXT:
status = find_next(ses, doc_view, 1);
break;
case ACT_MAIN_FIND_NEXT_BACK:
status = find_next(ses, doc_view, -1);
break;
case ACT_MAIN_FORGET_CREDENTIALS:
free_auth();
shrink_memory(1); /* flush caches */
break;
case ACT_MAIN_FORMHIST_MANAGER:
#ifdef CONFIG_FORMHIST
formhist_manager(ses);
#endif
break;
case ACT_MAIN_FRAME_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_FRAME);
break;
case ACT_MAIN_FRAME_NEXT:
next_frame(ses, 1);
draw_formatted(ses, 0);
break;
case ACT_MAIN_FRAME_MAXIMIZE:
status = set_frame(ses, doc_view, 0);
break;
case ACT_MAIN_FRAME_PREV:
next_frame(ses, -1);
draw_formatted(ses, 0);
break;
case ACT_MAIN_GOTO_URL:
goto_url_action(ses, NULL);
break;
case ACT_MAIN_GOTO_URL_CURRENT:
goto_url_action(ses, get_current_url);
break;
case ACT_MAIN_GOTO_URL_CURRENT_LINK:
goto_url_action(ses, get_current_link_url);
break;
case ACT_MAIN_GOTO_URL_HOME:
goto_url_home(ses);
break;
case ACT_MAIN_HEADER_INFO:
protocol_header_dialog(ses);
break;
case ACT_MAIN_HISTORY_MANAGER:
#ifdef CONFIG_GLOBHIST
history_manager(ses);
#endif
break;
case ACT_MAIN_HISTORY_MOVE_BACK:
{
int count = int_max(1, eat_kbd_repeat_count(ses));
go_history_by_n(ses, -count);
break;
}
case ACT_MAIN_HISTORY_MOVE_FORWARD:
{
int count = int_max(1, eat_kbd_repeat_count(ses));
go_history_by_n(ses, count);
break;
}
case ACT_MAIN_JUMP_TO_LINK:
break;
case ACT_MAIN_KEYBINDING_MANAGER:
keybinding_manager(ses);
break;
case ACT_MAIN_KILL_BACKGROUNDED_CONNECTIONS:
abort_background_connections();
break;
case ACT_MAIN_LINK_DIALOG:
open_link_dialog(ses);
break;
case ACT_MAIN_LINK_DOWNLOAD:
case ACT_MAIN_LINK_DOWNLOAD_IMAGE:
case ACT_MAIN_LINK_DOWNLOAD_RESUME:
status = download_link(ses, doc_view, action_id);
break;
case ACT_MAIN_LINK_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_LINK);
break;
case ACT_MAIN_LINK_FOLLOW:
status = enter(ses, doc_view, 0);
break;
case ACT_MAIN_LINK_FOLLOW_RELOAD:
status = enter(ses, doc_view, 1);
break;
case ACT_MAIN_LINK_INFO:
link_info_dialog(ses);
break;
case ACT_MAIN_LINK_MENU:
link_menu(term, NULL, ses);
break;
case ACT_MAIN_LINK_FORM_MENU:
link_form_menu(ses);
break;
case ACT_MAIN_LUA_CONSOLE:
#ifdef CONFIG_SCRIPTING_LUA
trigger_event_name("dialog-lua-console", ses);
#endif
break;
case ACT_MAIN_MARK_SET:
#ifdef CONFIG_MARKS
ses->kbdprefix.mark = KP_MARK_SET;
status = FRAME_EVENT_REFRESH;
#endif
break;
case ACT_MAIN_MARK_GOTO:
#ifdef CONFIG_MARKS
/* TODO: Show promptly a menu (or even listbox?)
* with all the marks. But the next letter must
* still choose a mark directly! --pasky */
ses->kbdprefix.mark = KP_MARK_GOTO;
status = FRAME_EVENT_REFRESH;
#endif
break;
case ACT_MAIN_MENU:
activate_bfu_technology(ses, -1);
break;
case ACT_MAIN_MOVE_CURRENT_TOP:
status = move_current_top(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_UP:
status = move_cursor_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_DOWN:
status = move_cursor_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_LEFT:
status = move_cursor_left(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_RIGHT:
status = move_cursor_right(ses, doc_view);
break;
case ACT_MAIN_MOVE_CURSOR_LINE_START:
status = move_cursor_line_start(ses, doc_view);
break;
case ACT_MAIN_MOVE_HALF_PAGE_DOWN:
status = move_half_page_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_HALF_PAGE_UP:
status = move_half_page_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_DOWN:
status = move_link_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_DOWN_LINE:
status = move_link_down_line(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_LEFT:
status = move_link_left(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_LEFT_LINE:
status = move_link_prev_line(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_NEXT:
status = move_link_next(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_PREV:
status = move_link_prev(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_RIGHT:
status = move_link_right(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_RIGHT_LINE:
status = move_link_next_line(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_UP:
status = move_link_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_LINK_UP_LINE:
status = move_link_up_line(ses, doc_view);
break;
case ACT_MAIN_MOVE_PAGE_DOWN:
status = move_page_down(ses, doc_view);
break;
case ACT_MAIN_MOVE_PAGE_UP:
status = move_page_up(ses, doc_view);
break;
case ACT_MAIN_MOVE_DOCUMENT_START:
status = move_document_start(ses, doc_view);
break;
case ACT_MAIN_MOVE_DOCUMENT_END:
status = move_document_end(ses, doc_view);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_TAB:
open_current_link_in_new_tab(ses, 0);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_TAB_IN_BACKGROUND:
open_current_link_in_new_tab(ses, 1);
break;
case ACT_MAIN_OPEN_LINK_IN_NEW_WINDOW:
open_in_new_window(term, send_open_in_new_window, ses);
break;
case ACT_MAIN_OPEN_NEW_TAB:
open_uri_in_new_tab(ses, NULL, 0, 1);
break;
case ACT_MAIN_OPEN_NEW_TAB_IN_BACKGROUND:
open_uri_in_new_tab(ses, NULL, 1, 1);
break;
case ACT_MAIN_OPEN_NEW_WINDOW:
open_in_new_window(term, send_open_new_window, ses);
break;
case ACT_MAIN_OPEN_OS_SHELL:
exec_shell(term);
break;
case ACT_MAIN_OPTIONS_MANAGER:
options_manager(ses);
break;
case ACT_MAIN_QUIT:
exit_prog(ses, 1);
break;
case ACT_MAIN_REALLY_QUIT:
exit_prog(ses, 0);
break;
case ACT_MAIN_REDRAW:
redraw_terminal_cls(term);
break;
case ACT_MAIN_RELOAD:
reload(ses, CACHE_MODE_INCREMENT);
break;
case ACT_MAIN_RERENDER:
draw_formatted(ses, 2);
break;
case ACT_MAIN_RESET_FORM:
status = reset_form(ses, doc_view, 0);
break;
case ACT_MAIN_RESOURCE_INFO:
resource_info(term);
break;
case ACT_MAIN_SAVE_AS:
status = save_as(ses, doc_view, 0);
break;
case ACT_MAIN_SAVE_FORMATTED:
status = save_formatted_dlg(ses, doc_view, 0);
break;
case ACT_MAIN_SAVE_OPTIONS:
write_config(term);
break;
case ACT_MAIN_SAVE_URL_AS:
save_url_as(ses);
break;
case ACT_MAIN_SCROLL_DOWN:
status = scroll_down(ses, doc_view);
break;
case ACT_MAIN_SCROLL_LEFT:
status = scroll_left(ses, doc_view);
break;
case ACT_MAIN_SCROLL_RIGHT:
status = scroll_right(ses, doc_view);
break;
case ACT_MAIN_SCROLL_UP:
status = scroll_up(ses, doc_view);
break;
case ACT_MAIN_SEARCH:
status = search_dlg(ses, doc_view, 1);
break;
case ACT_MAIN_SEARCH_BACK:
status = search_dlg(ses, doc_view, -1);
break;
case ACT_MAIN_SEARCH_TYPEAHEAD:
case ACT_MAIN_SEARCH_TYPEAHEAD_LINK:
case ACT_MAIN_SEARCH_TYPEAHEAD_TEXT:
case ACT_MAIN_SEARCH_TYPEAHEAD_TEXT_BACK:
status = search_typeahead(ses, doc_view, action_id);
break;
case ACT_MAIN_SHOW_TERM_OPTIONS:
terminal_options(term, NULL, ses);
break;
case ACT_MAIN_SUBMIT_FORM:
status = submit_form(ses, doc_view, 0);
break;
case ACT_MAIN_SUBMIT_FORM_RELOAD:
status = submit_form(ses, doc_view, 1);
break;
case ACT_MAIN_TAB_CLOSE:
close_tab(term, ses);
status = FRAME_EVENT_SESSION_DESTROYED;
break;
case ACT_MAIN_TAB_CLOSE_ALL_BUT_CURRENT:
close_all_tabs_but_current(ses);
break;
case ACT_MAIN_TAB_EXTERNAL_COMMAND:
status = pass_uri_to_command(ses, doc_view,
PASS_URI_TAB);
break;
case ACT_MAIN_TAB_MOVE_LEFT:
move_current_tab(ses, -1);
break;
case ACT_MAIN_TAB_MOVE_RIGHT:
move_current_tab(ses, 1);
break;
case ACT_MAIN_TAB_MENU:
assert(ses->tab == get_current_tab(term));
if (ses->status.show_tabs_bar)
tab_menu(ses, ses->tab->xpos,
term->height - 1
- ses->status.show_status_bar,
1);
else
tab_menu(ses, 0, 0, 0);
break;
case ACT_MAIN_TAB_NEXT:
switch_current_tab(ses, 1);
break;
case ACT_MAIN_TAB_PREV:
switch_current_tab(ses, -1);
break;
case ACT_MAIN_TERMINAL_RESIZE:
resize_terminal_dialog(term);
break;
case ACT_MAIN_TOGGLE_CSS:
#ifdef CONFIG_CSS
toggle_document_option(ses, "document.css.enable");
#endif
break;
case ACT_MAIN_TOGGLE_DISPLAY_IMAGES:
toggle_document_option(ses, "document.browse.images.show_as_links");
break;
case ACT_MAIN_TOGGLE_DISPLAY_TABLES:
toggle_document_option(ses, "document.html.display_tables");
break;
case ACT_MAIN_TOGGLE_DOCUMENT_COLORS:
toggle_document_option(ses, "document.colors.use_document_colors");
break;
case ACT_MAIN_TOGGLE_HTML_PLAIN:
toggle_plain_html(ses, ses->doc_view, 0);
break;
case ACT_MAIN_TOGGLE_MOUSE:
#ifdef CONFIG_MOUSE
toggle_mouse();
#endif
break;
case ACT_MAIN_TOGGLE_NUMBERED_LINKS:
toggle_document_option(ses, "document.browse.links.numbering");
break;
case ACT_MAIN_TOGGLE_PLAIN_COMPRESS_EMPTY_LINES:
toggle_document_option(ses, "document.plain.compress_empty_lines");
break;
case ACT_MAIN_TOGGLE_WRAP_TEXT:
toggle_wrap_text(ses, ses->doc_view, 0);
break;
case ACT_MAIN_VIEW_IMAGE:
status = view_image(ses, doc_view, 0);
break;
case ACT_MAIN_SCRIPTING_FUNCTION:
case ACT_MAIN_NONE:
case MAIN_ACTIONS:
default:
unknown_action:
if (verbose) {
INTERNAL("No action handling defined for '%s'.",
get_action_name(KEYMAP_MAIN, action_id));
}
status = FRAME_EVENT_IGNORED;
}
ignore_action:
/* XXX: At this point the session may have been destroyed */
if (status != FRAME_EVENT_SESSION_DESTROYED
&& ses->insert_mode == INSERT_MODE_ON
&& link != get_current_link(doc_view))
ses->insert_mode = INSERT_MODE_OFF;
if (status == FRAME_EVENT_REFRESH && doc_view)
refresh_view(ses, doc_view, 0);
return status;
}
static void
tmp_npclose(FILE *fp)
{
char buf[NFILEN + 128];
int rc, term_status;
(void) fflush(fp);
(void) fclose(fp);
if (stdout_fd != BAD_FD)
{
/*
* write pipe, but not a filter. Editor has written data to temp
* file, time now to exec "cmd" and hook its stdin to the file.
*
* It should be noted that exec'ing a process in the npclose()
* phase of a write pipe is not exactly keeping in spirit with
* the control flow in file.c :-) . However, the strategy used
* here ensures that the launched process reads a temp file that
* is completey flushed to disk. The only direct drawback with
* this approach is that when the exec'd process exits, the user
* does not receive a "[press return to continue]" prompt from
* file.c . But, cough, we can work around that problem :-) .
*/
if ((stdout_fd = open(stdout_name, O_RDONLY|O_BINARY)) == BAD_FD)
{
/* oh my, put complaint in user's face. */
sprintf(buf, "[unable to open temp file \"%s\": %s]",
stdout_name,
strerror(errno));
lastditch_msg(buf);
}
else
{
handles[0] = (HANDLE) _get_osfhandle(stdout_fd);
handles[1] = handles[2] = GetStdHandle(STD_OUTPUT_HANDLE);
rc = (exec_shell(shcmd,
handles,
FALSE /* don't hide child window */
) == BAD_PROC_HANDLE) ? FALSE : TRUE;
if (! rc)
{
/* Shell process failed, put complaint in user's face. */
sprintf(buf, SHELL_ERR_MSG, get_shell());
lastditch_msg(buf);
}
else
{
/* now wait for app to exit */
(void) cwait(&term_status, (CWAIT_PARAM_TYPE) proc_handle, 0);
TRACE(("...CreateProcess finished waiting in tmp_npclose\n"));
close_proc_handle();
}
/*
* When closing descriptors shared between parent and child,
* order is quite important when $shell == command.com . In
* this situation, the descriptors can't be closed until the
* exec'd process exits.
*/
close_fd(stdout_fd);
}
pressreturn(); /* cough */
sgarbf = TRUE;
}
tmp_cleanup();
}
static int
tmp_inout_popen(FILE **fr, FILE **fw, char *cmd)
{
char buf[NFILEN + 128];
DWORD dummy, len;
int rc, term_status, tmpin_fd;
TRACE(("tmp_inout_popen cmd=%s\n", cmd));
proc_handle = BAD_PROC_HANDLE;
handles[0] = handles[1] = handles[2] = INVALID_HANDLE_VALUE;
tmpin_fd = stdin_fd = stdout_fd = BAD_FD;
tmpin_name = stdin_name = stdout_name = NULL;
set_console_title(cmd);
do
{
if (fr)
{
*fr = NULL;
if ((stdin_name = _tempnam(getenv("TEMP"), "vile")) == NULL)
break;
if ((stdin_fd = open(stdin_name,
O_RDWR|O_CREAT|O_TRUNC|O_TEXT,
_S_IWRITE|_S_IREAD)) == BAD_FD)
{
break;
}
handles[2] = handles[1] = (HANDLE) _get_osfhandle(stdin_fd);
if (! fw)
{
/*
* This is a read pipe (only). Connect child's stdin to
* an empty file. Under no circumstances should the
* child's stdin be connected to a device (else lots of
* screwy things will occur). In particular, connecting
* the child's stdin to the parent's stdin will cause
* aborts and hangs on the various Win32 hosts. You've
* been warned.
*/
if ((tmpin_name = _tempnam(getenv("TEMP"), "vile")) == NULL)
break;
if ((tmpin_fd = open(tmpin_name,
O_RDONLY|O_CREAT|O_TRUNC,
_S_IWRITE|_S_IREAD)) == BAD_FD)
{
break;
}
handles[0] = (HANDLE) _get_osfhandle(tmpin_fd);
}
else
{
/*
* Set up descriptor for filter operation. Note the
* sublteties here: exec'd shell is passed a descriptor
* to the temp file that's opened "w". The editor
* receives a descriptor to the file that's opened "r".
*/
if ((*fr = fopen(stdin_name, "r")) == NULL)
break;
}
}
if (fw)
{
*fw = NULL;
/* create a temp file to receive data from the editor */
if ((stdout_name = _tempnam(getenv("TEMP"), "vile")) == NULL)
break;
if ((stdout_fd = open(stdout_name,
O_RDWR|O_CREAT|O_TRUNC|O_BINARY,
_S_IWRITE|_S_IREAD)) == BAD_FD)
{
break;
}
if ((*fw = fdopen(stdout_fd, "w")) == 0)
break;
/*
* we're all set up, but can't exec "cmd" until the editor
* writes data to the temp file connected to stdout.
*/
shcmd = cmd; /* remember this */
return (TRUE);
}
/* This must be a read (only) pipe. Appropriate to exec "cmd". */
rc = (exec_shell(cmd,
handles,
TRUE /* hide child wdw */
) == BAD_PROC_HANDLE) ? FALSE : TRUE;
if (! rc)
{
/*
* Shell process failed, put complaint in user's buffer, which
* is currently proxied by a temp file that the editor will
* suck in shortly.
*/
len = (DWORD) (lsprintf(buf, SHELL_ERR_MSG, get_shell()) - buf);
(void) WriteFile(handles[1], buf, len, &dummy, NULL);
FlushFileBuffers(handles[1]);
}
else
{
/* wait for exec'd process to exit */
(void) cwait(&term_status, (CWAIT_PARAM_TYPE) proc_handle, 0);
TRACE(("...CreateProcess finished waiting in tmp_inout_popen\n"));
close_proc_handle();
}
/*
* When closing descriptors shared between parent and child, order
* is quite important when $shell == command.com . In this
* situation, the descriptors can't be closed until the exec'd
* process exits (I kid you not).
*/
close_fd(stdin_fd);
(void) close(tmpin_fd);
/* let the editor consume the output of the read pipe */
if ((*fr = fopen(stdin_name, "r")) == NULL)
{
/*
* impossible to put error in user's buffer since that file
* descriptor is closed.
*/
sprintf(buf,
"[error opening temp file \"%s\": %s]",
stdin_name,
strerror(errno));
lastditch_msg(buf);
break;
}
return (rc);
}
while (FALSE);
/* If we get here -- some operation has failed. Clean up. */
tmp_cleanup();
return (FALSE);
}
/**
* Do everything before the fork and do everything the exec fork
*
* @param argc The number of command line arguments
* @param argv The command line arguments
*/
void do_login(int argc, char** argv)
{
char* username = NULL;
char* hostname = NULL;
char preserve_env = 0;
int ret;
#ifdef USE_TTY_GROUP
struct group* group;
#endif
#if AUTH > 0
/* Disable echoing */
passphrase_disable_echo1(STDIN_FILENO /* Will be the terminal. */);
/* This should be done as early and quickly as possible so as little
as possible of the passphrase gets leaked to the output if the user
begins entering the passphrase directly after the username. */
#endif
/* Set process group ID */
setpgrp();
/* Parse command line arguments */
{
char double_dashed = 0;
char hostname_on_next = 0;
int i;
for (i = 1; i < argc; i++)
{
char *arg = *(argv + i);
char c;
if (*arg == 0)
;
else if ((*arg == '-') && (double_dashed == 0))
while ((c = *(++arg)))
if (c == 'H')
;
else if (c == 'V')
_exit(2);
else if (c == 'p')
preserve_env = 1;
else if (c == 'h')
{
if (*(arg + 1))
hostname = arg + 1;
else
hostname_on_next = 1;
break;
}
else if (c == 'f')
{
if (*(arg + 1))
username = arg + 1;
skip_auth = 1;
break;
}
else if (c == '-')
{
double_dashed = 1;
break;
}
else
printf("%s: unrecognised options: -%c\n", *argv, c);
else if (hostname_on_next)
{
hostname = arg;
hostname_on_next = 0;
}
else
username = arg;
}
}
/* Change that a username has been specified */
if (username == NULL)
{
printf("%s: no username specified\n", *argv);
sleep(ERROR_SLEEP);
_exit(2);
}
/* Verify that the user may login */
ret = fork_exec_wait_hook(HOOK_VERIFY, argc, argv);
if ((ret >= 0) && WIFEXITED(ret) && (WEXITSTATUS(ret) == 1))
{
sleep(ERROR_SLEEP);
_exit(2);
}
if (skip_auth)
{
/* Reset terminal settings */
passphrase_reenable_echo1(STDIN_FILENO);
/* Only root may bypass authentication */
if (getuid())
{
printf("%s: only root by use the -f option\n", *argv);
sleep(ERROR_SLEEP);
_exit(2);
}
}
/* Print ant we want a passphrase, if -f has not been used */
else
{
printf("Passphrase: ");
fflush(stdout);
}
/* Done early to make to program look like it is even faster than it is */
/* Make sure nopony is spying */
#ifdef USE_TTY_GROUP
if ((group = getgrnam(TTY_GROUP)))
tty_group = group->gr_gid;
endgrent();
#endif
secure_tty(tty_group);
#if AUTH > 0
if (skip_auth == 0)
{
/* Redisable echoing */
passphrase_disable_echo1(STDIN_FILENO);
}
#endif
/* Set up clean quiting and time out */
signal(SIGALRM, timeout_quit);
signal(SIGQUIT, user_quit);
signal(SIGINT, user_quit);
siginterrupt(SIGALRM, 1);
siginterrupt(SIGQUIT, 1);
siginterrupt(SIGINT, 1);
#if AUTH > 0
alarm(TIMEOUT_SECONDS);
#endif
/* Get user information */
if ((entry = getpwnam(username)) == NULL)
{
if (errno)
perror("getpwnam");
else
printf("User does not exist\n");
sleep(ERROR_SLEEP);
_exit(1);
}
endpwent();
username = entry->pw_name;
/* Verify passphrase or other token, if -f has not been used */
ret = 2;
#if AUTH == 0
(void) hostname;
#else
initialise_login(hostname, username, read_passphrase);
if (skip_auth == 0)
ret = authenticate_login();
/* Passphrase entered, turn off timeout */
alarm(0);
#endif
if (ret == 2)
printf("(auto-authenticated)\n");
if (ret == 0)
{
preexit();
fork_exec_wait_hook(HOOK_DENIED, argc, argv);
xsleep(FAILURE_SLEEP);
_exit(1);
}
preexit();
/* Verify account, such as that it is enabled */
verify_account();
/* Run login hook */
fork_exec_wait_hook(HOOK_LOGIN, argc, argv);
/* Partial login */
chown_tty(entry->pw_uid, tty_group, 0);
chdir_home(entry);
ensure_shell(entry);
set_environ(entry, preserve_env);
open_login_session();
/* Stop signal handling */
signal(SIGALRM, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
signal(SIGTSTP, SIG_IGN);
child_pid = fork();
/* vfork cannot be used as the child changes the user,
the parent would not be able to chown the TTY */
if (child_pid == -1)
{
perror("fork");
close_login_session();
sleep(ERROR_SLEEP);
_exit(1);
}
else if (child_pid)
return; /* Do not go beyond this in the parent */
/* In case the shell does not do this */
setsid();
/* Set controlling terminal */
if (ioctl(STDIN_FILENO, TIOCSCTTY, 1))
perror("TIOCSCTTY");
signal(SIGINT, SIG_DFL);
/* Partial login */
ret = entry->pw_uid
? initgroups(username, entry->pw_gid) /* supplemental groups for user, can require network */
: setgroups(0, NULL); /* supplemental groups for root, does not require netork */
if (ret == -1)
{
perror(entry->pw_uid ? "initgroups" : "setgroups");
sleep(ERROR_SLEEP);
_exit(1);
}
set_user(entry);
exec_shell(entry);
}
int main(int argc, char **argv)
{
int opt = 0, port_num, client_len;
struct sockaddr_in server_addr, client_addr;
static struct option long_opts[] =
{
{"port", required_argument, 0, 'p'},
{"encrypt", no_argument, 0, 'e'}
};
while((opt = getopt_long(argc, argv, "p:e", long_opts, NULL)) != -1)
{
switch(opt)
{
case 'p':
//Grab port number
port_num = atoi(optarg);
break;
case 'e':
//Turn on Encryption
crypt_flag = 1;
//Get the key
char* key = grab_key("my.key");
//Initialize encryption and decryption
encryption_decryption_init(key, key_len);
break;
default:
//Usage message
fprintf(stderr, "Usage [e] port_number");
break;
}
}
//Set up socket connection
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if(socket_fd < 0) { perror("Error opening socket"); exit(1); }
memset((char*) &server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port_num);
server_addr.sin_addr.s_addr = INADDR_ANY;
if(bind(socket_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0)
{
perror("Error binding socket");
exit(1);
}
//Listen for data over the socket
listen(socket_fd, 5);
client_len = sizeof(client_addr);
//Block while accepting data input as a stream
newsocket_fd = accept(socket_fd, (struct sockaddr *) &client_addr, &client_len);
if(newsocket_fd < 0) { perror("Error accepting the socket"); exit(1); }
create_pipe(p1_fd);
create_pipe(p2_fd);
child_id = fork();
if(child_id < 0) { perror("Error forking"); exit(1); }
//Run the child process that is the shell
else if(child_id == 0) { exec_shell(); }
else
{
//Create the thread to send shell's output to the client
pthread_create(&thread_id, NULL, transfer_shell, &newsocket_fd);
}
//Redirect stdin/stdout/stderr to the socket
dup2(newsocket_fd, 0);
dup2(newsocket_fd, 1);
dup2(newsocket_fd, 2);
close(newsocket_fd);
read_write(0, p1_fd[1], 1);
encryption_decryption_deinit();
exit(0);
}
static void
do_login(const struct passwd *pwd, char *tty, char *ttyn)
{
#ifdef HAVE_GETSPNAM
struct spwd *sp;
#endif
int rootlogin = (pwd->pw_uid == 0);
gid_t tty_gid;
struct group *gr;
const char *home_dir;
int i;
if(!rootlogin)
checknologin();
#ifdef HAVE_GETSPNAM
sp = getspnam(pwd->pw_name);
#endif
update_utmp(pwd->pw_name, remote_host ? remote_host : "",
tty, ttyn);
gr = getgrnam ("tty");
if (gr != NULL)
tty_gid = gr->gr_gid;
else
tty_gid = pwd->pw_gid;
if (chown (ttyn, pwd->pw_uid, tty_gid) < 0) {
warn("chown %s", ttyn);
if (rootlogin == 0)
exit (1);
}
if (chmod (ttyn, S_IRUSR | S_IWUSR | S_IWGRP) < 0) {
warn("chmod %s", ttyn);
if (rootlogin == 0)
exit (1);
}
#ifdef HAVE_SETLOGIN
if(setlogin(pwd->pw_name)){
warn("setlogin(%s)", pwd->pw_name);
if(rootlogin == 0)
exit(1);
}
#endif
if(rootlogin == 0) {
const char *file = login_conf_get_string("limits");
if(file == NULL)
file = _PATH_LIMITS_CONF;
read_limits_conf(file, pwd);
}
#ifdef HAVE_SETPCRED
if (setpcred (pwd->pw_name, NULL) == -1)
warn("setpcred(%s)", pwd->pw_name);
#endif /* HAVE_SETPCRED */
#ifdef HAVE_INITGROUPS
if(initgroups(pwd->pw_name, pwd->pw_gid)){
warn("initgroups(%s, %u)", pwd->pw_name, (unsigned)pwd->pw_gid);
if(rootlogin == 0)
exit(1);
}
#endif
if(do_osfc2_magic(pwd->pw_uid))
exit(1);
if(setgid(pwd->pw_gid)){
warn("setgid(%u)", (unsigned)pwd->pw_gid);
if(rootlogin == 0)
exit(1);
}
if(setuid(pwd->pw_uid) || (pwd->pw_uid != 0 && setuid(0) == 0)) {
warn("setuid(%u)", (unsigned)pwd->pw_uid);
if(rootlogin == 0)
exit(1);
}
/* make sure signals are set to default actions, apparently some
OS:es like to ignore SIGINT, which is not very convenient */
for (i = 1; i < NSIG; ++i)
signal(i, SIG_DFL);
/* all kinds of different magic */
#ifdef HAVE_GETSPNAM
check_shadow(pwd, sp);
#endif
#if defined(HAVE_GETUDBNAM) && defined(HAVE_SETLIM)
{
struct udb *udb;
long t;
const long maxcpu = 46116860184; /* some random constant */
udb = getudbnam(pwd->pw_name);
if(udb == UDB_NULL)
errx(1, "Failed to get UDB entry.");
t = udb->ue_pcpulim[UDBRC_INTER];
if(t == 0 || t > maxcpu)
t = CPUUNLIM;
else
t *= 100 * CLOCKS_PER_SEC;
if(limit(C_PROC, 0, L_CPU, t) < 0)
warn("limit C_PROC");
t = udb->ue_jcpulim[UDBRC_INTER];
if(t == 0 || t > maxcpu)
t = CPUUNLIM;
else
t *= 100 * CLOCKS_PER_SEC;
if(limit(C_JOBPROCS, 0, L_CPU, t) < 0)
warn("limit C_JOBPROCS");
nice(udb->ue_nice[UDBRC_INTER]);
}
#endif
#if defined(HAVE_SGI_GETCAPABILITYBYNAME) && defined(HAVE_CAP_SET_PROC)
/* XXX SGI capability hack IRIX 6.x (x >= 0?) has something
called capabilities, that allow you to give away
permissions (such as chown) to specific processes. From 6.5
this is default on, and the default capability set seems to
not always be the empty set. The problem is that the
runtime linker refuses to do just about anything if the
process has *any* capabilities set, so we have to remove
them here (unless otherwise instructed by /etc/capability).
In IRIX < 6.5, these functions was called sgi_cap_setproc,
etc, but we ignore this fact (it works anyway). */
{
struct user_cap *ucap = sgi_getcapabilitybyname(pwd->pw_name);
cap_t cap;
if(ucap == NULL)
cap = cap_from_text("all=");
else
cap = cap_from_text(ucap->ca_default);
if(cap == NULL)
err(1, "cap_from_text");
if(cap_set_proc(cap) < 0)
err(1, "cap_set_proc");
cap_free(cap);
free(ucap);
}
#endif
home_dir = pwd->pw_dir;
if (chdir(home_dir) < 0) {
fprintf(stderr, "No home directory \"%s\"!\n", pwd->pw_dir);
if (chdir("/"))
exit(0);
home_dir = "/";
fprintf(stderr, "Logging in with home = \"/\".\n");
}
#ifdef KRB5
if (auth == AUTH_KRB5) {
krb5_start_session (pwd);
}
krb5_get_afs_tokens (pwd);
krb5_finish ();
#endif /* KRB5 */
add_env("PATH", _PATH_DEFPATH);
{
const char *str = login_conf_get_string("environment");
char buf[MAXPATHLEN];
if(str == NULL) {
login_read_env(_PATH_ETC_ENVIRONMENT);
} else {
while(strsep_copy(&str, ",", buf, sizeof(buf)) != -1) {
if(buf[0] == '\0')
continue;
login_read_env(buf);
}
}
}
{
const char *str = login_conf_get_string("motd");
char buf[MAXPATHLEN];
if(str != NULL) {
while(strsep_copy(&str, ",", buf, sizeof(buf)) != -1) {
if(buf[0] == '\0')
continue;
show_file(buf);
}
} else {
str = login_conf_get_string("welcome");
if(str != NULL)
show_file(str);
}
}
add_env("HOME", home_dir);
add_env("USER", pwd->pw_name);
add_env("LOGNAME", pwd->pw_name);
add_env("SHELL", pwd->pw_shell);
exec_shell(pwd->pw_shell, rootlogin);
}
/**
* Executes a rule. Contains evaluation of all conditions prior
* to execution.
*
* @1 Hotplug event structure
* @2 The rule to be executed
*
* Returns: 0 if success, -1 if the whole event is to be
* discared, 1 if bail out of this particular rule was required
*/
int rule_execute(struct hotplug2_event_t *event, struct rule_t *rule) {
int i, last_rv, res;
char **env;
for (i = 0; i < rule->conditions_c; i++) {
if (rule_condition_eval(event, &(rule->conditions[i])) != EVAL_MATCH)
return 0;
}
res = 0;
last_rv = 0;
env = xmalloc(sizeof(char *) * event->env_vars_c);
for (i = 0; i < event->env_vars_c; i++) {
env[i] = alloc_env(event->env_vars[i].key, event->env_vars[i].value);
putenv(env[i]);
}
for (i = 0; i < rule->actions_c; i++) {
switch (rule->actions[i].type) {
case ACT_STOP_PROCESSING:
res = 1;
break;
case ACT_STOP_IF_FAILED:
if (last_rv != 0)
res = 1;
break;
case ACT_NEXT_EVENT:
res = -1;
break;
case ACT_NEXT_IF_FAILED:
if (last_rv != 0)
res = -1;
break;
case ACT_MAKE_DEVICE:
last_rv = make_dev_from_event(event, rule->actions[i].parameter[0], strtoul(rule->actions[i].parameter[1], NULL, 0));
break;
case ACT_CHMOD:
last_rv = chmod_file(event, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
break;
case ACT_CHOWN:
case ACT_CHGRP:
last_rv = chown_chgrp(event, rule->actions[i].type, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
break;
case ACT_SYMLINK:
last_rv = make_symlink(event, rule->actions[i].parameter[0], rule->actions[i].parameter[1]);
break;
case ACT_RUN_SHELL:
last_rv = exec_shell(event, rule->actions[i].parameter[0]);
break;
case ACT_RUN_NOSHELL:
last_rv = exec_noshell(event, rule->actions[i].parameter[0], rule->actions[i].parameter);
break;
case ACT_SETENV:
last_rv = setenv(rule->actions[i].parameter[0], rule->actions[i].parameter[1], 1);
break;
case ACT_REMOVE:
last_rv = unlink(rule->actions[i].parameter[0]);
rmdir_p(rule->actions[i].parameter[0]);
break;
case ACT_DEBUG:
print_debug(event);
last_rv = 0;
break;
}
if (res != 0)
break;
}
for (i = 0; i < event->env_vars_c; i++) {
unsetenv(event->env_vars[i].key);
free(env[i]);
}
free(env);
return res;
}
int
main(int argc, char *argv[])
{
struct sbuf *cmdbuf;
long arg_max;
int ch, debug, i, magic, n, nargs, offset, rval;
size_t cmdsize;
char *cmd, *name, *p, *shell, *slashp, *tmpshell;
debug = 0;
magic = '%'; /* Default magic char is `%'. */
nargs = -1;
while ((ch = getopt(argc, argv, "a:d0123456789")) != -1)
switch (ch) {
case 'a':
if (optarg[1] != '\0')
errx(1,
"illegal magic character specification");
magic = optarg[0];
break;
case 'd':
debug = 1;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (nargs != -1)
errx(1,
"only one -# argument may be specified");
nargs = optopt - '0';
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (argc < 2)
usage();
/*
* The command to run is argv[0], and the args are argv[1..].
* Look for %digit references in the command, remembering the
* largest one.
*/
for (n = 0, p = argv[0]; *p != '\0'; ++p)
if (p[0] == magic && isdigit(p[1]) && p[1] != '0') {
++p;
if (p[0] - '0' > n)
n = p[0] - '0';
}
/*
* Figure out the shell and name arguments to pass to execl()
* in exec_shell(). Always malloc() shell and just set name
* to point at the last part of shell if there are any backslashes,
* otherwise just set it to point at the space malloc()'d. If
* SHELL environment variable exists, replace contents of
* shell with it.
*/
shell = name = NULL;
tmpshell = getenv("SHELL");
shell = (tmpshell != NULL) ? strdup(tmpshell) : strdup(_PATH_BSHELL);
if (shell == NULL)
err(1, "strdup() failed");
slashp = strrchr(shell, '/');
name = (slashp != NULL) ? slashp + 1 : shell;
/*
* If there were any %digit references, then use those, otherwise
* build a new command string with sufficient %digit references at
* the end to consume (nargs) arguments each time round the loop.
* Allocate enough space to hold the maximum command. Save the
* size to pass to snprintf().
*/
cmdsize = sizeof(EXEC) - 1 + strlen(argv[0])
+ 9 * (sizeof(" %1") - 1) + 1;
if ((cmd = malloc(cmdsize)) == NULL)
err(1, NULL);
if (n == 0) {
/* If nargs not set, default to a single argument. */
if (nargs == -1)
nargs = 1;
p = cmd;
offset = snprintf(cmd, cmdsize, EXEC "%s", argv[0]);
if ((size_t)offset >= cmdsize)
errx(1, "snprintf() failed");
p += offset;
cmdsize -= offset;
for (i = 1; i <= nargs; i++) {
offset = snprintf(p, cmdsize, " %c%d", magic, i);
if ((size_t)offset >= cmdsize)
errx(1, "snprintf() failed");
p += offset;
cmdsize -= offset;
}
/*
* If nargs set to the special value 0, eat a single
* argument for each command execution.
*/
if (nargs == 0)
nargs = 1;
} else {
offset = snprintf(cmd, cmdsize, EXEC "%s", argv[0]);
if ((size_t)offset >= cmdsize)
errx(1, "snprintf() failed");
nargs = n;
}
cmdbuf = sbuf_new(NULL, NULL, 1024, SBUF_AUTOEXTEND);
if (cmdbuf == NULL)
err(1, NULL);
arg_max = sysconf(_SC_ARG_MAX);
/*
* (argc) and (argv) are still offset by one to make it simpler to
* expand %digit references. At the end of the loop check for (argc)
* equals 1 means that all the (argv) has been consumed.
*/
for (rval = 0; argc > nargs; argc -= nargs, argv += nargs) {
sbuf_clear(cmdbuf);
/* Expand command argv references. */
for (p = cmd; *p != '\0'; ++p) {
if (p[0] == magic && isdigit(p[1]) && p[1] != '0') {
if (sbuf_cat(cmdbuf, argv[(++p)[0] - '0'])
== -1)
errc(1, ENOMEM, "sbuf");
} else {
if (sbuf_putc(cmdbuf, *p) == -1)
errc(1, ENOMEM, "sbuf");
}
if (sbuf_len(cmdbuf) > arg_max)
errc(1, E2BIG, NULL);
}
/* Terminate the command string. */
sbuf_finish(cmdbuf);
/* Run the command. */
if (debug)
(void)printf("%s\n", sbuf_data(cmdbuf));
else
if (exec_shell(sbuf_data(cmdbuf), shell, name))
rval = 1;
}
if (argc != 1)
errx(1, "expecting additional argument%s after \"%s\"",
(nargs - argc) ? "s" : "", argv[argc - 1]);
free(cmd);
sbuf_delete(cmdbuf);
free(shell);
exit(rval);
}
int main(int argc, char **argv)
{
int childpid;
int sfd = -1;
int fd;
char *p, *ptyslave=NULL;
int i = 1;
int off_argv;
int calculated_pipename = 0;
int highest_pipe_num = 0;
program_name = argv[0];
if(argc<4) {
usage(argv[0]);
exit(1);
}
init_outbuf();
if (!strcmp(argv[1],"-daemon")) {
daemon_init();
++i;
}
off_argv = i;
strn_cpy(pipename, sizeof(pipename), argv[i++]);
strn_cpy(log_dir, sizeof(log_dir), argv[i]);
strn_cpy(statusfile, sizeof(statusfile), log_dir);
strn_cat(statusfile, sizeof(statusfile), STATUSFILENAME);
#ifdef DEBUG
status("%s: pid is : %d\n", argv[0], getpid());
#endif
/* Get values for LOG file handling from the environment */
if ((p = getenv("RUN_ERL_LOG_ALIVE_MINUTES"))) {
log_alive_minutes = atoi(p);
if (!log_alive_minutes) {
ERROR1(LOG_ERR,"Minimum value for RUN_ERL_LOG_ALIVE_MINUTES is 1 "
"(current value is %s)",p);
}
log_activity_minutes = log_alive_minutes / 3;
if (!log_activity_minutes) {
++log_activity_minutes;
}
}
if ((p = getenv("RUN_ERL_LOG_ACTIVITY_MINUTES"))) {
log_activity_minutes = atoi(p);
if (!log_activity_minutes) {
ERROR1(LOG_ERR,"Minimum value for RUN_ERL_LOG_ACTIVITY_MINUTES is 1 "
"(current value is %s)",p);
}
}
if ((p = getenv("RUN_ERL_LOG_ALIVE_FORMAT"))) {
if (strlen(p) > ALIVE_BUFFSIZ) {
ERROR1(LOG_ERR, "RUN_ERL_LOG_ALIVE_FORMAT can contain a maximum of "
"%d characters", ALIVE_BUFFSIZ);
}
strn_cpy(log_alive_format, sizeof(log_alive_format), p);
} else {
strn_cpy(log_alive_format, sizeof(log_alive_format), DEFAULT_LOG_ALIVE_FORMAT);
}
if ((p = getenv("RUN_ERL_LOG_ALIVE_IN_UTC")) && strcmp(p,"0")) {
++log_alive_in_gmt;
}
if ((p = getenv("RUN_ERL_LOG_GENERATIONS"))) {
log_generations = atoi(p);
if (log_generations < LOG_MIN_GENERATIONS)
ERROR1(LOG_ERR,"Minimum RUN_ERL_LOG_GENERATIONS is %d", LOG_MIN_GENERATIONS);
if (log_generations > LOG_MAX_GENERATIONS)
ERROR1(LOG_ERR,"Maximum RUN_ERL_LOG_GENERATIONS is %d", LOG_MAX_GENERATIONS);
}
if ((p = getenv("RUN_ERL_LOG_MAXSIZE"))) {
log_maxsize = atoi(p);
if (log_maxsize < LOG_MIN_MAXSIZE)
ERROR1(LOG_ERR,"Minimum RUN_ERL_LOG_MAXSIZE is %d", LOG_MIN_MAXSIZE);
}
/*
* Create FIFOs and open them
*/
if(*pipename && pipename[strlen(pipename)-1] == '/') {
/* The user wishes us to find a unique pipe name in the specified */
/* directory */
DIR *dirp;
struct dirent *direntp;
calculated_pipename = 1;
dirp = opendir(pipename);
if(!dirp) {
ERRNO_ERR1(LOG_ERR,"Can't access pipe directory '%s'.", pipename);
exit(1);
}
/* Check the directory for existing pipes */
while((direntp=readdir(dirp)) != NULL) {
if(strncmp(direntp->d_name,PIPE_STUBNAME,PIPE_STUBLEN)==0) {
int num = atoi(direntp->d_name+PIPE_STUBLEN+1);
if(num > highest_pipe_num)
highest_pipe_num = num;
}
}
closedir(dirp);
strn_catf(pipename, sizeof(pipename), "%s.%d",
PIPE_STUBNAME, highest_pipe_num+1);
} /* if */
for(;;) {
/* write FIFO - is read FIFO for `to_erl' program */
strn_cpy(fifo1, sizeof(fifo1), pipename);
strn_cat(fifo1, sizeof(fifo1), ".r");
if (create_fifo(fifo1, PERM) < 0) {
ERRNO_ERR1(LOG_ERR,"Cannot create FIFO %s for writing.", fifo1);
exit(1);
}
/* read FIFO - is write FIFO for `to_erl' program */
strn_cpy(fifo2, sizeof(fifo2), pipename);
strn_cat(fifo2, sizeof(fifo2), ".w");
/* Check that nobody is running run_erl already */
if ((fd = sf_open(fifo2, O_WRONLY|DONT_BLOCK_PLEASE, 0)) >= 0) {
/* Open as client succeeded -- run_erl is already running! */
sf_close(fd);
if (calculated_pipename) {
++highest_pipe_num;
strn_catf(pipename, sizeof(pipename), "%s.%d",
PIPE_STUBNAME, highest_pipe_num+1);
continue;
}
fprintf(stderr, "Erlang already running on pipe %s.\n", pipename);
exit(1);
}
if (create_fifo(fifo2, PERM) < 0) {
ERRNO_ERR1(LOG_ERR,"Cannot create FIFO %s for reading.", fifo2);
exit(1);
}
break;
}
/*
* Open master pseudo-terminal
*/
if ((mfd = open_pty_master(&ptyslave, &sfd)) < 0) {
ERRNO_ERR0(LOG_ERR,"Could not open pty master");
exit(1);
}
/*
* Now create a child process
*/
if ((childpid = fork()) < 0) {
ERRNO_ERR0(LOG_ERR,"Cannot fork");
exit(1);
}
if (childpid == 0) {
/* Child */
sf_close(mfd);
/* disassociate from control terminal */
#ifdef USE_SETPGRP_NOARGS /* SysV */
setpgrp();
#elif defined(USE_SETPGRP) /* BSD */
setpgrp(0,getpid());
#else /* POSIX */
setsid();
#endif
/* Open the slave pty */
if (sfd < 0) {
/* not allocated by open_pty_master */
if ((sfd = open_pty_slave(ptyslave)) < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open pty slave '%s'", ptyslave);
exit(1);
}
/* But sfd may be one of the stdio fd's now, and we should be unmodern and not use dup2... */
/* easiest to dup it up... */
while (sfd < 3) {
sfd = dup(sfd);
}
}
#if defined(HAVE_OPENPTY) && defined(TIOCSCTTY)
else {
/* sfd is from open_pty_master
* openpty -> fork -> login_tty (forkpty)
*
* It would be preferable to implement a portable
* forkpty instead of open_pty_master / open_pty_slave
*/
/* login_tty(sfd); <- FAIL */
ioctl(sfd, TIOCSCTTY, (char *)NULL);
}
#endif
#ifndef NO_SYSLOG
/* Before fiddling with file descriptors we make sure syslog is turned off
or "closed". In the single case where we might want it again,
we will open it again instead. Would not want syslog to
go to some other fd... */
if (run_daemon) {
closelog();
}
#endif
/* Close stdio */
sf_close(0);
sf_close(1);
sf_close(2);
if (dup(sfd) != 0 || dup(sfd) != 1 || dup(sfd) != 2) {
status("Cannot dup\n");
}
sf_close(sfd);
exec_shell(argv+off_argv); /* exec_shell expects argv[2] to be */
/* the command name, so we have to */
/* adjust. */
} else {
/* Parent */
/* Ignore the SIGPIPE signal, write() will return errno=EPIPE */
struct sigaction sig_act;
sigemptyset(&sig_act.sa_mask);
sig_act.sa_flags = 0;
sig_act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sig_act, (struct sigaction *)NULL);
sigemptyset(&sig_act.sa_mask);
sig_act.sa_flags = SA_NOCLDSTOP;
sig_act.sa_handler = catch_sigchild;
sigaction(SIGCHLD, &sig_act, (struct sigaction *)NULL);
/*
* read and write: enter the workloop
*/
pass_on(childpid);
}
return 0;
} /* main() */
void Valter::shellExecuteIndistinctThreadWorker(string cmd, string qDebugMsg)
{
qDebug("%s ← [%s]",qDebugMsg.c_str(), cmd.c_str());
string result = exec_shell(cmd);
qDebug("%s → %s",qDebugMsg.c_str(), result.c_str());
}
static int
native_inout_popen(FILE **fr, FILE **fw, char *cmd)
{
char buf[NFILEN + 128];
HANDLE handles[3];
int i, rc, rp[3], tmpin_fd, wp[3];
TRACE((T_CALLED "native_inout_popen cmd=%s\n", cmd));
proc_handle = BAD_PROC_HANDLE;
rp[0] = rp[1] = rp[2] = wp[0] = wp[1] = wp[2] = BAD_FD;
handles[0] = handles[1] = handles[2] = INVALID_HANDLE_VALUE;
tmpin_fd = BAD_FD;
tmpin_name = NULL;
set_console_title(cmd);
if (is_win95())
{
char *cmdp;
/*
* If w32pipes is set on a win95 host, you don't ever want slowreadf()
* to periodically update the display while an intrinisic, high
* bandwidth DOS command is in progress. Reason: the win95 shell,
* command.com, will simply hang in the following scenario:
*
* ^X!<high_bandwidth_cmd>
*
* and
*
* PIPESIZ < output of <high_bandwidth_cmd>
*
* I'm assuming that what's going on here is that command.com is
* written in ASM and is using very low level BIOS/DOS calls to
* effect output and, furthermore, that these low level calls don't
* block when the input consumer is busy.
*/
cmdp = skip_blanks(cmd);
nowait_pipe_cmd = (strnicmp(cmdp, "dir", 3) == 0) ||
(strnicmp(cmdp, "type", 4) == 0);
}
do
{
if (fr)
{
*fr = NULL;
/*
* Open (parent's) input pipe in TEXT mode, which will force
* translation of the child's CR/LF record delimiters to NL
* and keep the dreaded ^M chars from temporarily appearing
* in a vile buffer (ugly).
*/
if (_pipe(rp, PIPESIZ, O_TEXT|O_NOINHERIT) == -1)
break;
if ((rp[2] = _dup(rp[1])) == -1)
break;
handles[2] = handles[1] = (HANDLE) _get_osfhandle(rp[2]);
(void) close(rp[1]);
rp[1] = BAD_FD;
if (! fw)
{
/*
* This is a read pipe (only). Connect child's stdin to
* an empty file. Under no circumstances should the
* child's stdin be connected to a device (else lots of
* screwy things will occur). In particular, connecting
* the child's stdin to the parent's stdin will cause
* aborts and hangs on the various Win32 hosts. You've
* been warned.
*/
if ((tmpin_name = _tempnam(getenv("TEMP"), "vile")) == NULL)
break;
if ((tmpin_fd = open(tmpin_name,
O_RDONLY|O_CREAT|O_TRUNC,
_S_IWRITE|_S_IREAD)) == BAD_FD)
{
break;
}
handles[0] = (HANDLE) _get_osfhandle(tmpin_fd);
}
if ((*fr = fdopen(rp[0], "r")) == 0)
break;
}
if (fw)
{
*fw = NULL;
/*
* Open (child's) output pipe in binary mode, which will
* prevent translation of the parent's CR/LF record delimiters
* to NL. Apparently, many apps want those delimiters :-) .
*/
if (_pipe(wp, PIPESIZ, O_BINARY|O_NOINHERIT) == -1)
break;
if ((wp[2] = _dup(wp[0])) == -1)
break;
handles[0] = (HANDLE)_get_osfhandle(wp[2]);
(void) close(wp[0]);
wp[0] = BAD_FD;
if (! fr)
handles[1] = handles[2] = GetStdHandle(STD_OUTPUT_HANDLE);
if ((*fw = fdopen(wp[1], "w")) == 0)
break;
}
rc = (exec_shell(cmd,
handles,
fr != NULL /* Child wdw hidden unless write pipe. */
) == BAD_PROC_HANDLE) ? FALSE : TRUE;
if (fw)
{
if (! rc)
{
/* Shell process failed, put complaint in user's face. */
sprintf(buf, SHELL_ERR_MSG, get_shell());
lastditch_msg(buf);
}
w32_close_handle(handles[0]);
}
if (fr)
{
if (! rc)
{
unsigned len;
/*
* Shell process failed, put complaint in user's buffer.
* Can't write to handles[1] on a win2k host because the
* previously failed CreateProcess() call damaged the
* handle.
*/
len = (unsigned) (lsprintf(buf, SHELL_ERR_MSG, get_shell()) - buf);
(void) write(rp[2], buf, len);
(void) close(rp[2]); /* in weird state; why not? */
}
w32_close_handle(handles[1]);
close_fd(tmpin_fd);
}
returnCode(rc);
}
while (FALSE);
/* If we get here -- some operation has failed. Clean up. */
close_fd(wp[0]);
close_fd(wp[1]);
close_fd(wp[2]);
close_fd(rp[0]);
close_fd(rp[1]);
close_fd(rp[2]);
close_fd(tmpin_fd);
for (i = 0; i < 3; i++)
{
if (handles[i] != INVALID_HANDLE_VALUE)
w32_close_handle(handles[i]);
}
common_cleanup();
returnCode(FALSE);
}
