void
IRC_Client_GUI_MessageHandler::members (const string_list_t& list_in)
{
RPG_TRACE (ACE_TEXT ("IRC_Client_GUI_MessageHandler::members"));
// sanity check(s)
ACE_ASSERT (CBData_.GTKState);
ACE_Guard<ACE_Thread_Mutex> aGuard (CBData_.GTKState->lock);
Common_UI_GTKBuildersIterator_t iterator =
CBData_.GTKState->builders.find (builderLabel_);
// sanity check(s)
ACE_ASSERT (iterator != CBData_.GTKState->builders.end ());
if (isFirstMemberListMsg_)
{
clearMembers ();
isFirstMemberListMsg_ = false;
} // end IF
// retrieve channel liststore handle
GtkListStore* list_store_p =
GTK_LIST_STORE (gtk_builder_get_object ((*iterator).second.second,
ACE_TEXT_ALWAYS_CHAR ("channel_liststore")));
ACE_ASSERT (list_store_p);
GtkTreeIter iter;
gchar* converted_nick_string = NULL;
for (string_list_const_iterator_t iterator = list_in.begin ();
iterator != list_in.end ();
iterator++)
{
// step1: convert text
converted_nick_string = Common_UI_Tools::Locale2UTF8 (*iterator);
if (!converted_nick_string)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to convert nickname: \"%s\", returning\n")));
return;
} // end IF
// step2: append new (text) entry
gtk_list_store_append (list_store_p, &iter);
gtk_list_store_set (list_store_p, &iter,
0, converted_nick_string, // column 0
-1);
// clean up
g_free (converted_nick_string);
} // end FOR
}
bool
ServerPasswd::getKeys(string_list_t& keys)
{
map_array_t entries;
if (getEntries(entries) && entries.size() > 0)
{
map_array_t::iterator it;
for (it = entries.begin(); it != entries.end(); it++)
{
keys.push_back(it->second[SP_KEY].c_str() + 1);
}
return true;
}
return false;
}
/**
Try to find the specified file in any of the possible directories
where mime files can be located. This code is shamelessly stolen
from xdg_run_command_on_dirs.
\param list Full file paths will be appended to this list.
\param f The relative filename search for the the data directories.
\param all If zero, then stop after the first filename.
\return The number of filenames added to the list.
*/
static int append_filenames( string_list_t &list, const char *f, int all )
{
size_t prev_count = list.size();
char *result;
const char *xdg_data_home;
const char *xdg_data_dirs;
const char *ptr;
xdg_data_home = getenv ("XDG_DATA_HOME");
if (xdg_data_home)
{
result = file_exists( xdg_data_home, f );
if (result)
{
list.push_back(result);
if ( !all )
return 1;
}
}
else
{
const char *home;
home = getenv ("HOME");
if (home != NULL)
{
char *guessed_xdg_home;
guessed_xdg_home = (char *)my_malloc (strlen (home) + strlen ("/.local/share") + 1);
if( !guessed_xdg_home )
return 0;
strcpy (guessed_xdg_home, home);
strcat (guessed_xdg_home, "/.local/share");
result = file_exists( guessed_xdg_home, f );
free (guessed_xdg_home);
if (result)
{
list.push_back(result);
if ( !all )
return 1;
}
}
}
xdg_data_dirs = getenv ("XDG_DATA_DIRS");
if (xdg_data_dirs == NULL)
xdg_data_dirs = "/usr/local/share:/usr/share";
ptr = xdg_data_dirs;
while (*ptr != '\000')
{
const char *end_ptr;
char *dir;
int len;
end_ptr = ptr;
while (*end_ptr != ':' && *end_ptr != '\000')
end_ptr ++;
if (end_ptr == ptr)
{
ptr++;
continue;
}
len = end_ptr - ptr;
dir = (char *)my_malloc (len + 1);
if( !dir )
return 0;
strncpy (dir, ptr, len);
dir[len] = '\0';
result = file_exists( dir, f );
free (dir);
if (result)
{
list.push_back(result);
if ( !all ) {
return 1;
}
}
ptr = end_ptr;
}
return list.size() - prev_count;
}
/**
Use the specified launch filter to launch all the files in the specified list.
\param filter the action to take
\param files the list of files for which to perform the action
\param fileno an internal value. Should always be set to zero.
*/
static void launch( char *filter, const string_list_t &files, size_t fileno )
{
char *filter_org=filter;
int count=0;
int launch_again=0;
if( files.size() <= fileno )
return;
launch_pos=0;
for( ;*filter && !error; filter++)
{
if(*filter == '%')
{
filter++;
switch( *filter )
{
case 'u':
{
launch_again = 1;
write_url( files.at(fileno).c_str() );
break;
}
case 'U':
{
for( size_t i=0; i<files.size(); i++ )
{
if( i != 0 )
writer( ' ' );
write_url( files.at(i).c_str() );
if( error )
break;
}
break;
}
case 'f':
case 'n':
{
launch_again = 1;
write_file( files.at(fileno).c_str(), *filter == 'f' );
break;
}
case 'F':
case 'N':
{
for( size_t i=0; i<files.size(); i++ )
{
if( i != 0 )
writer( ' ' );
write_file( files.at(i).c_str(), *filter == 'F' );
if( error )
break;
}
break;
}
case 'd':
{
const char *cpy = get_fullfile( files.at(fileno).c_str() );
char *dir;
launch_again=1;
/*
We wish to modify this string, make sure it is only a copy
*/
if( cpy == files.at(fileno).c_str())
cpy = my_strdup( cpy );
if( cpy == 0 )
{
break;
}
dir=dirname( (char *)cpy );
write_file( dir, 1 );
free( (void *)cpy );
break;
}
case 'D':
{
for( size_t i=0; i<files.size(); i++ )
{
const char *cpy = get_fullfile( files.at(i).c_str() );
char *dir;
/*
We wish to modify this string, make sure it is only a copy
*/
if( cpy == files.at(i).c_str() )
cpy = my_strdup( cpy );
if( cpy == 0 )
{
break;
}
dir=dirname( (char *)cpy );
if( i != 0 )
writer( ' ' );
write_file( dir, 1 );
free( (void *)cpy );
}
break;
}
default:
fprintf( stderr, _("%s: Unsupported switch '%c' in launch string '%s'\n"), MIMEDB, *filter, filter_org );
launch_len=0;
break;
}
}
else
{
writer( *filter );
count++;
}
}
if( error )
return;
switch( launch_len )
{
case -1:
{
launch_len = 0;
fprintf( stderr, _( "%s: Out of memory\n"), MIMEDB );
return;
}
case 0:
{
return;
}
default:
{
writer( ' ' );
writer( '&' );
writer( '\0' );
if( system( launch_buff ) == -1 )
{
fprintf( stderr, _( ERROR_SYSTEM ), MIMEDB, launch_buff );
exit(STATUS_ERROR_SYSTEM);
}
break;
}
}
if( launch_again )
{
launch( filter_org, files, fileno+1 );
}
}
int
ShellServer::caller(ServerContext& s, const char *cmd, string_list_t& args, string_map_t& env, process_io_t& io)
{
int result = 0;
int status = 0;
int pid = 0;
int fdin[2]; /* child stdin - parent output */
int fdout[2]; /* Child stdout - parent block input */
int fderr[2]; /* Child stderr - parent result input */
int nargs = (int) args.size();
int nvars = (int) env.size();
string command = m_binpath + SEPSTR + cmd;
args.push_front(command);
(void) result;
if (::access(command.c_str(), X_OK) < 0)
{
return -ENOSYS;
}
/* Make pipes */
if (pipe(fdin) < 0)
{
perror("Can't make pipe");
return -errno;
}
if (pipe(fdout) < 0)
{
perror("Can't make pipe");
return -errno;
}
if (pipe(fderr) < 0)
{
perror("Can't make pipe");
return -errno;
}
unsigned int i = 0;
const char *envp[nvars + 3];
const char *argvs[nargs + 1];
char envbuf[2048];
char *envptr = envbuf;
argvs[nargs + 1] = NULL;
envp[nvars + 2] = NULL;
string c = command;
i = 0;
for (string_list_t::iterator it = args.begin(); it != args.end(); it++)
{
argvs[i++] = (*it).c_str();
c += string(" ") + *it;
}
argvs[i] = 0;
_DEBUG("-Running: %s", c.c_str());
i = 0;
for (string_map_t::iterator it = env.begin(); it != env.end(); it++)
{
sprintf(envptr, "%s=%s", it->first.c_str(), it->second.c_str());
_DEBUG("-env: %s=%s", it->first.c_str(), it->second.c_str());
envp[i++] = envptr;
envptr += strlen(envptr) + 1;
}
sprintf(envptr, "INETFS_CWD=%s", m_datapath.c_str());
envp[i++] = envptr;
envptr += strlen(envptr) + 1;
sprintf(envptr, "PWD=%s", m_datapath.c_str());
envp[i++] = envptr;
envptr += strlen(envptr) + 1;
envp[i] = NULL;
switch ((pid = ::vfork()))
{
case -1:
/* error */
//perror("Can't fork");
_DEBUG("-cfork failed with errno = %d", errno);
return -errno;
case 0:
/* Child. */
{
_DEBUG("+Child process");
::close(2);
if (2 != dup(fderr[1]))
{
ASSERT(0);
}
::close(1); /* Close current stdout. */
if (1 != ::dup(fdout[1])) /* Make stdout go to write end of pipe. */
{
ASSERT(0);
}
::close(0); /* Close current stdin. */
if (0 != ::dup(fdin[0])) /* Make stdin come from read end of pipe. */
{
ASSERT(0);
}
::close(fderr[0]);
::close(fdout[0]);
::close(fdin[1]);
::chdir(m_datapath.c_str());
::execvpe(command.c_str(), (char **) argvs, (char **) envp);
status = -errno;
perror("No exec");
//signal(getppid(), SIGQUIT);
return status;
}
default:
/* Parent. */
/* Close what we don't need. */
{
::close(fderr[1]);
::close(fdout[1]);
::close(fdin[0]);
#if 0
struct sigaction sa;
sa.sa_handler = &handle_sigchld;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sa, 0) < 0)
{
perror("-Failed to set SIGCLD handler");
::close(fderr[0]);
::close(fdout[0]);
::close(fdin[1]);
return -errno;
}
#endif
// write client stdin processing
FILE* cfd_err = fdopen(fderr[0], "r");
FILE* cfd_in = NULL;
if (io.input.length() > 0)
{
cfd_in = fdopen(fdin[1], "w");
fwrite(io.input.c_str(), io.input.length(), 1, cfd_in);
fflush(cfd_in);
}
//read client sdtout
//FILE* cfd_out = fdopen(fdout[1], "r");
if (fdout[0] > 0)
{
char buffer[4096];
int readlen = 0;
do
{
readlen = (int) ::read(fdout[0], buffer, (int) sizeof(buffer));
if (readlen < 0)
{
result = -errno;
break;
}
io.output.append(buffer, readlen);
}
while (readlen != 0);
}
if (!io.output.empty() && strncmp("@error ", io.output.c_str(), 7) == 0)
{
result = -atoi(io.output.c_str() + 7);
}
_DEBUG("-waiting for pid = %d", pid);
if (waitpid(pid, &status, WNOHANG) < 0 && result == 0)
{
result = -errno;
if (result == -ECHILD) // ignore ECHILD
{
result = 0;
}
}
if (result == 0 && WIFEXITED(status))
{
result = -WEXITSTATUS(status);
}
status = result;
if (cfd_in)
{
fclose(cfd_in);
}
#if 0
if (cfd_out)
{
fclose(cfd_out);
}
#endif
if (cfd_err)
{
fclose(cfd_err);
}
::close(fderr[0]);
::close(fdout[0]);
::close(fdin[1]);
}
}
return status;
}
