int receive_clients(int fd)
{
t_fd fds;
int ret;
t_all all;
init_buffer(&(all.buf));
all.fds = &fds;
all.channel = NULL;
all.fds->fd_s = fd;
all.actual = NULL;
new_channel(&all, "toto");
new_channel(&all, "titi");
if ((add_fd(&all, SERVER_ID, fd, &serv_ptr)) == -1)
return (-1);
while (1)
{
all.fds->max_fd = set_fds(&all, &(all.fds->fd_read));
FD_ZERO(&(all.fds->fd_write));
if ((ret = select(all.fds->max_fd + 1, &(all.fds->fd_read),
&(all.fds->fd_write),
NULL, NULL)) == -1)
return (1);
check_fd(&all);
}
return (0);
}
static gboolean
example_csh_room_manager_request (ExampleCSHRoomManager *self,
gpointer request_token,
GHashTable *request_properties,
gboolean require_new)
{
TpHandle handle;
ExampleCSHRoomChannel *chan;
GError *error = NULL;
if (tp_strdiff (tp_asv_get_string (request_properties,
TP_PROP_CHANNEL_CHANNEL_TYPE),
TP_IFACE_CHANNEL_TYPE_TEXT))
{
return FALSE;
}
if (tp_asv_get_uint32 (request_properties,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL) != TP_HANDLE_TYPE_ROOM)
{
return FALSE;
}
handle = tp_asv_get_uint32 (request_properties,
TP_PROP_CHANNEL_TARGET_HANDLE, NULL);
g_assert (handle != 0);
if (tp_channel_manager_asv_has_unknown_properties (request_properties,
fixed_properties, allowed_properties, &error))
{
goto error;
}
chan = g_hash_table_lookup (self->priv->channels, GUINT_TO_POINTER (handle));
if (chan == NULL)
{
new_channel (self, handle, self->priv->conn->self_handle,
request_token);
}
else if (require_new)
{
g_set_error (&error, TP_ERRORS, TP_ERROR_NOT_AVAILABLE,
"A Text channel for room #%u already exists", handle);
goto error;
}
else
{
tp_channel_manager_emit_request_already_satisfied (self,
request_token, TP_EXPORTABLE_CHANNEL (chan));
}
return TRUE;
error:
tp_channel_manager_emit_request_failed (self, request_token,
error->domain, error->code, error->message);
g_error_free (error);
return TRUE;
}
static int join_hook(int argc, char *argv[])
{
assert(argc == 2);
/**********************************************
* allow something like:
* /join #channel1 #channel2
**********************************************/
if (strstr(argv[1], " ")) {
int i;
char **tmp_argv;
int tmp_argc;
char *orig = argv[1];
make_argv(&tmp_argc, &tmp_argv, argv[1]);
for (i = 0; i < tmp_argc; i++) {
argv[1] = tmp_argv[i];
join_hook(argc, argv);
}
free_argv(tmp_argc, tmp_argv);
argv[1] = orig;
return 0;
}
channel_t *tmp;
tmp = find_channel(argv[1], irc_pick_server());
if (tmp == NULL)
tmp = new_channel(argv[1], irc_pick_server());
tmp->set_window(tmp, active_window <= window_max
&& active_window > 0 ? active_window : 0);
tmp->join(tmp);
return 0;
}
void set_global() {
if (packets[pnum].cmds.size() < NCHANNELS) {
for (int i=0; i<NCHANNELS; i++) {
if (!isChannelIncluded(packets[pnum], i)) {
new_channel(i);
}
}
}
for (int i=0; i<NCHANNELS; i++) {
if (debug_) printf("global: enabling channel %d\n", i);
packets[pnum].cmds[i].ena = true;
packets[pnum].cmds[i].upd = true;
}
flag_global = true;
}
bool CARBON_GUI::new_channel()
{
int i;
lock();
for (i=0;i<MAX_CHANNELS;i++) {
if(channel[i] == NULL) {
if(new_channel(i)) {
unlock();
return true;
}
}
}
unlock();
msg->warning("Actually MuSE doesn't support more than %d parallel input channels",MAX_CHANNELS);
return false;
}
static int end_of_names_hook(int argc, char *argv[])
{
const char **nicks = users_in_channel(argv[3]);
channel_t *ch = find_channel(argv[3], irc_pick_server());
int del_chn = 0;
if(ch == NULL) {
ch = new_channel(argv[3], irc_pick_server());
del_chn = 1;
}
int j;
/**************************************
* find the longest nick
**************************************/
int longest = 0;
for(j = 0; nicks[j] != NULL; j++) {
if(strlen(nicks[j]) > longest)
longest = strlen(nicks[j]);
}
int sizex = io_get_width();
int times = sizex / (longest + 4);
/**************************************
* show the nicks
**************************************/
wio_colored_out(ch->win, USER_BLUE, " [%s]\n", argv[3]);
if(nicks[1] != NULL) {
for(j = 0; nicks[j] != NULL; j++) {
if(j && j % times == 0)
wio_out(ch->win, "\n");
wio_colored_out(ch->win, USER_RED, " [");
wio_colored_out(ch->win, USER_WHITE, "%-*s", longest, nicks[j]);
wio_colored_out(ch->win, USER_RED, "] ");
}
wio_out(ch->win, "\n");
}
free(nicks);
if(del_chn)
delete_channel(ch);
return 0;
}
bool set_channel(std::vector<uint8_t> data) {
int num = decode_be(data);
if (num <= NCHANNELS) {
if (debug_) printf("set channel number=%d\n", num);
if (num == 0) {
flag_global = true;
chan = num;
set_global();
} else {
flag_global = false;
chan = num - 1;
if (!isChannelIncluded(packets[pnum], num))
new_channel(chan);
}
return true;
}
if (debug_) printf("failed to set channel number=%d\n", num);
return false;
}
static gboolean
simulate_incoming_call_cb (gpointer p)
{
ExampleCallManager *self = p;
TpHandleRepoIface *contact_repo;
TpHandle caller;
/* do nothing if we've been disconnected while waiting for the contact to
* call us */
if (self->priv->available_id == 0)
return FALSE;
/* We're called by someone whose ID on the IM service is "caller" */
contact_repo = tp_base_connection_get_handles (self->priv->conn,
TP_HANDLE_TYPE_CONTACT);
caller = tp_handle_ensure (contact_repo, "caller", NULL, NULL);
new_channel (self, caller, caller, NULL, TRUE, FALSE);
return FALSE;
}
void create_channel(ServiceRecord *sc){
ChannelState * state = new_channel();
if (state == NULL) return;
state->remote_addr = sc->remote_addr;
state->ccb.client_process = home_channel_state.ccb.client_process;
state->ccb.callback = home_channel_state.ccb.callback;
state->rate = home_channel_state.rate;
DataPayload *new_dp = &(state->packet);
clean_packet(new_dp);
ConnectMsg *cm = (ConnectMsg *)new_dp->data;
strcpy(cm->name, controller_name);
cm->rate = uip_htons(state->rate);
new_dp->hdr.dst_chan_num = 0;
new_dp->hdr.src_chan_num = state->chan_num;
(new_dp)->hdr.cmd = CONNECT;
(new_dp)->dhdr.tlen = uip_htons(sizeof(ConnectMsg));
send_on_knot_channel(state,new_dp);
state->state = STATE_CONNECT;
state->ticks = 10;
}
static server*
new_server(char *host, char *port)
{
server *s;
if ((s = calloc(1, sizeof(*s))) == NULL)
fatal("calloc");
/* Set non-zero default fields */
s->soc = -1;
s->iptr = s->input;
s->nptr = config.nicks;
s->host = strdup(host);
s->port = strdup(port);
auto_nick(&(s->nptr), s->nick);
s->channel = ccur = new_channel(host, s, NULL, BUFFER_SERVER);
DLL_ADD(server_head, s);
return s;
}
static Chunk *new_chunk(Song *song, size_t nb_channels)
{
Chunk *chunk;
song->nb_chunks++;
if(song->chunks_l)
{
song->chunks_l->next = malloc(sizeof(Chunk));
song->chunks_l = song->chunks_l->next;
}
else
song->chunks_f = song->chunks_l = malloc(sizeof(Chunk));
chunk = song->chunks_l;
chunk->next = NULL;
chunk->nb_channels = nb_channels;
chunk->pos = 0;
chunk->channels = malloc(sizeof(Channel*) * nb_channels);
if(g_debug)
fprintf(stderr, "Creating channel 0\n");
chunk->channels[0] = new_channel();
return chunk;
}
servercontroller::servercontroller( QWidget*, const char* name )
: KMainWindow( 0, name )
{
we_are_exiting = false;
m_notificationCount = 0;
m_ncm = new nickColourMaker();
MenuBar = menuBar();
KWin::setIcons( winId(), kapp->icon(), kapp->miniIcon() );
s_self = this;
switch (ksopts->displayMode)
{
case KSOptions::SDI:
displayMgr = new DisplayMgrSDI();
break;
case KSOptions::MDI:
displayMgr = new DisplayMgrMDI();
break;
}
sci = new scInside(this, QCString(name) + "_mainview");
setCentralWidget(sci);
sci->setFrameStyle(QFrame::Box | QFrame::Raised);
ConnectionTree = sci->ConnectionTree;
connect(ConnectionTree, SIGNAL(clicked( QListViewItem * )),
this, SLOT(WindowSelected(QListViewItem *)));
setFrameBorderWidth(5);
QPopupMenu *file = new QPopupMenu(this, QCString(name) + "_menu_file");
KStdAction::quit(this, SLOT(endksirc()), actionCollection())->plug(file);
#ifndef NDEBUG
file->insertItem(i18n("Dump Object Tree"), this, SLOT(dump_obj()));
file->insertItem(i18n("Server Debug Window"), this, SLOT(server_debug()));
#endif
MenuBar->insertItem(i18n("&File"), file);
connections = new QPopupMenu(this, QCString(name) + "_menu_connections");
server_id = connections->insertItem(i18n("&New Server..."), this, SLOT(new_connection()), Key_F2 );
join_id = connections->insertItem(i18n("&Join Channel..."), this, SLOT(new_channel()), Key_F3 );
connections->insertSeparator();
connections->insertItem(i18n("&Do Autoconnect..."), this, SLOT(start_autoconnect_check()));
connections->setItemEnabled(join_id, FALSE);
MenuBar->insertItem(i18n("&Connections"), connections);
options = new QPopupMenu(this, QCString(name) + "_menu_options");
options->setCheckable(TRUE);
options->insertItem(SmallIcon( "filter" ), i18n("&Filter Rule Editor..."),
this, SLOT(filter_rule_editor()));
options->insertSeparator();
KStdAction::configureNotifications(this, SLOT(notification_prefs()), actionCollection())->plug(options);
KStdAction::preferences(this, SLOT(general_prefs()), actionCollection())->plug(options);
MenuBar->insertItem(i18n("&Settings"), options);
KHelpMenu *help = new KHelpMenu( this, kapp->aboutData() );
MenuBar->insertItem( KStdGuiItem::help().text(), help->menu() );
m_kga = new KGlobalAccel(this, "globalAccess");
m_kga->insert("New Server", i18n("New Server"),
i18n("This action allows you to open a new server more easily "
"when in docked mode, since you don't need to click on the "
"dock icon."),
ALT+CTRL+Key_C, KKey::QtWIN+CTRL+Key_C, this,
SLOT(new_connection()));
open_toplevels = 0;
pic_server = UserIcon("server");
pic_gf = UserIcon("ksirc_a");
pic_run = UserIcon("mini-run");
pic_ppl = UserIcon("channels");
pic_icon = UserIcon("ksirc_b");
setCaption( i18n("Server Control") );
KWin::setIcons(winId(), pic_icon, pic_server);
resize( 450,200 );
dockWidget = new dockServerController(this, 0x0, "servercontroller_dock");
KWin::setSystemTrayWindowFor( dockWidget->winId(), winId() );
m_kga->readSettings();
m_kga->updateConnections();
checkDocking();
}
/* load the predefined channels */
void load_channels(void)
{
char path[_POSIX_PATH_MAX], *name, *slimit, *slevel, *topic, *ptr;
char realname[256];
int fd;
int limit, level, line = 0;
CHANNEL *chan;
int version = 0;
snprintf(path, sizeof(path), "%s/channels", global.varDir);
if((fd = open(path, O_RDONLY))==-1)
{
if(errno != ENOENT)
logerr("load_channels", path);
return;
}
if(fake_fgets(Buf, sizeof(Buf), fd) == NULL)
{
close(fd);
return;
}
if(!strncmp(":version 1", Buf, 10))
version = 1;
else
lseek(fd, 0, SEEK_SET);
while (fake_fgets(Buf, sizeof(Buf), fd))
{
line++;
ptr = Buf;
while (ISSPACE(*ptr))
ptr++;
if(*ptr == 0 || (version == 0 && *ptr == '#'))
continue; /* blank or comment line */
name = next_arg(&ptr);
slimit = next_arg(&ptr);
slevel = next_arg(&ptr);
topic = next_arg(&ptr);
if(!name || !slimit || !slevel || !topic)
{
log_message_level(LOG_LEVEL_ERROR, "load_channels: %s:%d: too few parameters", path, line);
continue;
}
/* force new channel name restrictions */
if(option(ON_IRC_CHANNELS) && *name != '#' && *name != '&')
{
snprintf(realname, sizeof(realname), "#%s", name);
name = realname;
}
if(invalid_channel(name))
{
log_message_level(LOG_LEVEL_ERROR, "load_channels: %s:%d: %s: invalid channel name", name);
continue;
}
level = get_level(slevel);
if(level == -1)
{
log_message_level(LOG_LEVEL_ERROR, "load_channels: %s:%d: %s: invalid level", path, line, slevel);
continue;
}
limit = atoi(slimit);
if(limit < 0 || limit > 65535)
{
log_message_level(LOG_LEVEL_ERROR, "load_channels: %s:%d: %d: invalid limit", path, line, limit);
continue;
}
chan = hash_lookup(global.channelHash, name);
if(chan)
{
log_message_level(LOG_LEVEL_ERROR, "load_channels: %s:%d: %s is already defined", path, line, name);
continue;
}
chan = new_channel();
if(chan)
{
chan->name = STRDUP(name);
chan->topic = STRDUP(topic);
chan->limit = limit;
chan->level = level;
chan->flags = ON_CHANNEL_REGISTERED;
chan->timestamp = global.current_time;
}
if(hash_add(global.channelHash, chan->name, chan))
free_channel(chan);
}
close(fd);
}
/* Constructor for CARBON_GUI class. */
CARBON_GUI::CARBON_GUI(int argc, char **argv, Stream_mixer *mix)
: GUI(argc,argv,mix)
{
/* initialization stuff */
jmix = mix;
memset(myLcd,0,sizeof(myLcd));
memset(myPos,0,sizeof(myPos));
vumeter=0;
vuband=0;
selectedChannel=NULL;
memset(channel,0,sizeof(channel));
playlistManager=new PlaylistManager();
msgList=new Linklist();
/* init mutex used when accessing the statusbox buffer ...
* this is needed because other threads can try to write status messages concurrently
*/
if(pthread_mutex_init(&_statusLock,NULL) == -1) {
error("error initializing POSIX thread mutex creating a new CarbonChannel");
QuitApplicationEventLoop();
}
// Create a Nib reference
err = CreateNibReference(CFSTR("main"), &nibRef);
if(err != noErr) error("Can't get NIB reference to obtain gui controls!!");
// Create the MainWindow using nib resource file
err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
if(err != noErr) {
error("Can't create MainWindow!!");
QuitApplicationEventLoop();
}
else {
msg = new CarbonMessage(nibRef);
/* make the main window also the frontmost one */
BringToFront(window);
init_controls();
/* now create the menu to use for the menubar ... it's stored in nib */
err=CreateMenuFromNib(nibRef,CFSTR("MenuBar"),&mainMenu);
if(err!=noErr) {
msg->error("Can't create main menu (%d)!!",err);
}
/* install vumeter controls */
setupVumeters();
/* and the status box */
setupStatusWindow();
bufferInspector = new BufferInspector(window,nibRef,jmix);
/* now we have to group windows together so if all are visible they will also be layered together */
err=CreateWindowGroup(kWindowGroupAttrLayerTogether,&mainGroup);
err=SetWindowGroup(window,mainGroup);
err=SetWindowGroup(vumeterWindow,mainGroup);
err=SetWindowGroup(statusWindow,mainGroup);
err=SetWindowGroup(bufferInspector->window,mainGroup);
SetWindowGroupOwner(mainGroup,window);
/* let's create a channel window for each active input channel */
unsigned int i;
bool cc=false;
for (i=0;i<MAX_CHANNELS;i++) {
strcpy(ch_lcd[i],"00:00:00");
if(jmix->chan[i]) {
CarbonChannel *newChan = new CarbonChannel(jmix,this,nibRef,i);
channel[i] = newChan;
/*
if(i > 0) {
RepositionWindow(channel[i]->window,channel[i-1]->window,kWindowCascadeOnParentWindow);
}
else {
RepositionWindow(channel[i],window,kWindowCascadeOnParentWindow);
}
*/
cc=true;
}
else {
channel[i] = NULL;
}
}
/* Ok, once MainWindow has been created and we have instantiated all acrive input channels,
* we need an instance of CarbonStream to control the stream option window */
streamHandler = new CarbonStream(jmix,window,nibRef);
/* by default we want at leat one active channel */
if(!cc) new_channel();
aboutWindow = new AboutWindow(window,nibRef);
// The window was created hidden so show it.
ShowWindow( window );
}
}
static Song *read_song(FILE *file)
{
Command command;
Song *song = malloc(sizeof(Song));
Chunk *chunk = NULL;
song->ended = 0;
song->nb_chunks = 0;
song->chunks_f = song->chunks_l = NULL;
if(g_debug)
fprintf(stderr, "Starting parsing of song file...\n");
while(read_line(file, &command) != -1)
{
switch(command.command)
{
case '\0':
break;
case 'p':
{
if(g_debug)
fprintf(stderr, "New chunk (%d channels)\n",
command.number.param);
if(command.number.param < 1)
return NULL;
if(chunk)
chunk->pos = 0;
chunk = new_chunk(song, command.number.param);
}
break;
case 'v':
{
/* select channel from chunk
* a new chunk may be allocated */
Channel *channel = find_channel(song, &chunk);
/* set the volume */
channel->volume = command.number.param;
}
break;
case 'i':
{
/* select channel from chunk
* a new chunk may be allocated */
Channel *channel = find_channel(song, &chunk);
/* set the instrument */
channel->instrument = command.number.param;
}
break;
case 'n':
{
size_t i;
/* select channel from chunk
* a new chunk may be allocated */
Channel *channel = find_channel(song, &chunk);
/* fill it with notes! */
channel->length = strlen(command.string.param);
channel->notes = malloc(sizeof(float) * channel->length);
for(i = 0; i < channel->length; i++)
channel->notes[i] = note2freq(command.string.param[i]);
if(g_debug)
fprintf(stderr, "%u notes read into channel %u\n",
channel->length, chunk->pos);
/* to next channel */
chunk->pos++;
if(chunk->pos < chunk->nb_channels)
chunk->channels[chunk->pos] = new_channel();
}
break;
case 'l':
case 'j':
fprintf(stderr, "Warning: '%c' is currently unimplemented\n",
command.command);
break;
}
}
if(chunk->pos != chunk->nb_channels)
{
fprintf(stderr, "Missing %d channels in chunk\n",
chunk->nb_channels - chunk->pos);
return NULL;
}
chunk->pos = 0;
if(g_debug)
fprintf(stderr, "Song file parsed\n");
return song;
}
ConnInterface::ConnInterface()
{
channel = new_channel();
//ROS_ASSERT_MSG(channel >= 0, "channel allocation failure");
}
