/* module init function */
int add_led_module_cmds(void *pdata) {
cmd_register(WIRINGPI_CMD_TYPE, LED_ON, led_on, led_on_info);
cmd_register(WIRINGPI_CMD_TYPE, LED_OFF, led_off, led_off_info);
cmd_register(WIRINGPI_CMD_TYPE, WIRINGPI_INIT, wiringPi_init, wiringPi_init_info);
cmd_register(WIRINGPI_CMD_TYPE, WIRINGPI_EXIT, wiringPi_exit, wiringPi_exit_info);
return 0;
}
static __constructor void
ifconfig_ctor(void)
{
#ifdef __rtems__
memset(&ifr, 0, sizeof(ifr));
memset(&name, 0, sizeof(name));
descr = NULL;
descrlen = 64;
setaddr = 0;
setmask = 0;
doalias = 0;
clearaddr = 0;
newaddr = 1;
verbose = 0;
noload = 0;
supmedia = 0;
printkeys = 0;
opts = NULL;
afs = NULL;
callbacks = NULL;
cmds = NULL;
#endif /* __rtems__ */
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(basic_cmds); i++)
cmd_register(&basic_cmds[i]);
#undef N
}
static int module_init(void)
{
struct contacts *contacts = baresip_contacts();
char path[256] = "", file[256] = "";
int err;
err = conf_path_get(path, sizeof(path));
if (err)
return err;
if (re_snprintf(file, sizeof(file), "%s/contacts", path) < 0)
return ENOMEM;
if (!conf_fileexist(file)) {
(void)fs_mkdir(path, 0700);
err = write_template(file);
if (err)
return err;
}
err = conf_parse(file, confline_handler, contacts);
if (err)
return err;
err = cmd_register(baresip_commands(), cmdv, ARRAY_SIZE(cmdv));
if (err)
return err;
info("Populated %u contacts\n",
list_count(contact_list(contacts)));
return err;
}
static int module_init(void)
{
int err = 0;
err = mqueue_alloc(&mod_obj.mq, mqueue_handler, &mod_obj);
if (err)
return err;
aufilt_register(baresip_aufiltl(), &vumeter);
#ifdef USE_NOTIFICATIONS
err = message_listen(&mod_obj.message, baresip_message(),
message_handler, &mod_obj);
if (err) {
warning("gtk: message_init failed (%m)\n", err);
return err;
}
#endif
err = cmd_register(baresip_commands(), cmdv, ARRAY_SIZE(cmdv));
if (err)
return err;
/* start the thread last */
err = pthread_create(&mod_obj.thread, NULL, gtk_thread,
&mod_obj);
if (err)
return err;
return err;
}
static int module_init(void)
{
int err = 0;
err = mqueue_alloc(&mod_obj.mq, mqueue_handler, &mod_obj);
if (err)
return err;
aufilt_register(&vumeter);
#ifdef USE_NOTIFICATIONS
err = message_init(message_handler, &mod_obj);
if (err)
return err;
#endif
err = cmd_register(cmdv, ARRAY_SIZE(cmdv));
if (err)
return err;
/* start the thread last */
err = pthread_create(&mod_obj.thread, NULL, gtk_thread,
&mod_obj);
if (err)
return err;
return err;
}
void cmd_register_list(struct command *cmd, const char *parent_name)
{
while(cmd->name)
{
cmd_register(cmd, parent_name);
cmd++;
}
}
/*
=================
r_texture_init
=================
*/
erbool r_texture_init (void)
{
textures = NULL;
cmd_register("r_list_textures", NULL, &r_list_textures_f, 0);
return true;
}
static __constructor void
ifmedia_ctor(void)
{
size_t i;
for (i = 0; i < nitems(media_cmds); i++)
cmd_register(&media_cmds[i]);
af_register(&af_media);
}
static __constructor void
bridge_ctor(void)
{
int i;
for (i = 0; i < nitems(bridge_cmds); i++)
cmd_register(&bridge_cmds[i]);
af_register(&af_bridge);
}
static __constructor(101) void
lagg_ctor(void)
{
size_t i;
for (i = 0; i < nitems(lagg_cmds); i++)
cmd_register(&lagg_cmds[i]);
af_register(&af_lagg);
}
static __constructor void
fib_ctor(void)
{
size_t i;
for (i = 0; i < nitems(fib_cmds); i++)
cmd_register(&fib_cmds[i]);
af_register(&af_fib);
}
/*
=================
engine_start
=================
*/
erbool engine_start (void)
{
init_time();
sys_get_time();
INIT(cvar);
INIT(cmd);
INIT(cmdbuf);
cmd_register("quit", NULL, &quit_f, 0);
cmd_register("echo", NULL, &echo_f, 0);
INIT(fs);
INIT(keyboard);
cmdbuf_add("exec config.cfg\n", CMD_SRC_ENGINE);
cmdbuf_frame();
INIT(mouse);
INIT(image);
INIT(video);
INIT(gl);
INIT(r);
INIT(snd);
INIT(g);
cmdbuf_add("exec autoexec.cfg\n", CMD_SRC_ENGINE);
cmdbuf_frame();
/*
put sys args into cmdbuf (which begin with '+')
once again (after all cmds like 'map' were registered)
*/
sys_arg_to_cmdbuf('+');
cmdbuf_frame();
return true;
error:
engine_stop();
return false;
}
static __constructor void
ipsec_ctor(void)
{
size_t i;
for (i = 0; i < nitems(ipsec_cmds); i++)
cmd_register(&ipsec_cmds[i]);
af_register(&af_ipsec);
#undef N
}
static __constructor void
ifconfig_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(basic_cmds); i++)
cmd_register(&basic_cmds[i]);
#undef N
}
int notifier_init(void)
{
int err;
err = sipevent_listen(&evsock, uag_sip(), 32, 32, sub_handler, NULL);
if (err)
return err;
return cmd_register(cmdv, ARRAY_SIZE(cmdv));
}
static __constructor void
atalk_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(atalk_cmds); i++)
cmd_register(&atalk_cmds[i]);
af_register(&af_atalk);
#undef N
}
static __constructor void
lagg_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
for (i = 0; i < N(lagg_cmds); i++)
cmd_register(&lagg_cmds[i]);
af_register(&af_lagg);
#undef N
}
static __constructor void
ifmedia_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(media_cmds); i++)
cmd_register(&media_cmds[i]);
af_register(&af_media);
#undef N
}
static __constructor void
vlan_ctor(void)
{
size_t i;
for (i = 0; i < nitems(vlan_cmds); i++)
cmd_register(&vlan_cmds[i]);
af_register(&af_vlan);
callback_register(vlan_cb, NULL);
clone_setdefcallback("vlan", vlan_create);
}
static __constructor(101) void
bridge_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
for (i = 0; i < N(bridge_cmds); i++)
cmd_register(&bridge_cmds[i]);
af_register(&af_bridge);
#undef N
}
static __constructor(101) void
carp_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
for (i = 0; i < N(carp_cmds); i++)
cmd_register(&carp_cmds[i]);
af_register(&af_carp);
#undef N
}
static __constructor void
group_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
for (i = 0; i < N(group_cmds); i++)
cmd_register(&group_cmds[i]);
af_register(&af_group);
opt_register(&group_gopt);
#undef N
}
static int module_init(void)
{
int err;
start_ticks = tmr_jiffies();
(void)time(&start_time);
err = cmd_register(baresip_commands(),
debugcmdv, ARRAY_SIZE(debugcmdv));
return err;
}
static __constructor(101) void
vlan_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
int i;
for (i = 0; i < N(vlan_cmds); i++)
cmd_register(&vlan_cmds[i]);
af_register(&af_vlan);
callback_register(vlan_cb, NULL);
#undef N
}
static __constructor void
vxlan_ctor(void)
{
#define N(a) (sizeof(a) / sizeof(a[0]))
size_t i;
for (i = 0; i < N(vxlan_cmds); i++)
cmd_register(&vxlan_cmds[i]);
af_register(&af_vxlan);
callback_register(vxlan_cb, NULL);
clone_setdefcallback("vxlan", vxlan_create);
#undef N
}
/** Initialize and register commands. */
void cmd_init(void)
{
unsigned int i;
for (i = 0; basic_commands[i]; i++) {
cmd_initialize(basic_commands[i]);
}
for (i = 0; basic_commands[i]; i++) {
if (!cmd_register(basic_commands[i])) {
printf("Cannot register command %s\n",
basic_commands[i]->name);
}
}
}
int manager_init() {
if(manager_core_init(assign_default_handlers)) {
printf("\tCan't open manager server\n");
return -1;
}
manager_core = manager_core_server_open(MANAGER_DEFAULT_PORT);
if(!manager_core) {
printf("\tCan't open manager server\n");
return -2;
}
vm_stdio_handler(stdio_callback);
if(cmd_register(commands, sizeof(commands) / sizeof(commands[0]))) {
printf("\tCan't register command\n");
return -3;
}
return 0;
}
void vidrec_init_once(int width, int height, int framerate, int bitrate, enum AVCodecID codec_id, struct mbuf *sps, struct mbuf *pps)
{
if (int_initialized) {
return;
}
int_width = width;
int_height = height;
int_framerate = framerate;
int_bitrate = bitrate;
int_codec_id = codec_id;
int_sps = mbuf_alloc_ref(sps);
int_pps = mbuf_alloc_ref(pps);
int_was_key_frame = false;
cmd_register(cmdv, ARRAY_SIZE(cmdv));
int_initialized = 1;
debug("Video recording is initialized\n");
}
void sysproc_hotkeys(void)
{
char *newPid, *newPrio;
int pid, prio;
msg_envelope_t *msg;
cmd_register("%C");
while (1) {
msg = receive_message(NULL);
if (msg->header.type == CMD_NOTIFY_MSG) {
newPid = &msg->data[3];
newPrio = cmd_parse(newPid);
pid = atoi(newPid);
prio = atoi(newPrio);
if (proc_is_valid_pid(pid) && prio >= HIGH && prio <= LOWEST) {
set_priority(prio, pid);
}
} else {
switch (msg->header.ctrl) {
case 'v': {
proc_print(msg, RDY);
} break;
case 'x': {
proc_print(msg, BLOCKED);
} break;
case 'c': {
proc_print(msg, MSG_BLOCKED);
} break;
}
}
free_message(msg);
}
}
static int module_init(void)
{
vidfilt_register(&snapshot);
return cmd_register(cmdv, ARRAY_SIZE(cmdv));
}
