void board_init_f_init_reserve(ulong base)
{
struct global_data *gd_ptr;
/*
* clear GD entirely and set it up.
* Use gd_ptr, as gd may not be properly set yet.
*/
gd_ptr = (struct global_data *)base;
/* zero the area */
memset(gd_ptr, '\0', sizeof(*gd));
/* set GD unless architecture did it already */
#if !defined(CONFIG_ARM)
arch_setup_gd(gd_ptr);
#endif
/* next alloc will be higher by one GD plus 16-byte alignment */
base += roundup(sizeof(struct global_data), 16);
/*
* record early malloc arena start.
* Use gd as it is now properly set for all architectures.
*/
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
/* go down one 'early malloc arena' */
gd->malloc_base = base;
/* next alloc will be higher by one 'early malloc arena' size */
base += CONFIG_VAL(SYS_MALLOC_F_LEN);
#endif
}
CHANNEL_HISTORY_DEQUE *init_channel_history(CHANNEL *chan, apeconfig *config) {
char *config_val = CONFIG_VAL(Channels, history_default_max_size, config);
if (config_val != NULL && atoi(config_val) > 0) {
CHANNEL_HISTORY_DEQUE *deque = new_channel_history();
add_property(&chan->properties, "max_history_size", config_val, EXTEND_STR, EXTEND_ISPRIVATE);
config_val = CONFIG_VAL(Channels, history_default_raw_filter, config);
if (config_val != NULL) {
S_TOUPPER(config_val);
if (strcmp(config_val, "ALL") != 0) {
deque->filter = config_val;
}
}
return deque;
}
return NULL;
}
unsigned int cmd_script(callbackp *callbacki)
{
char *domain = CONFIG_VAL(Server, domain, callbacki->g_ape->srv);
char *script = NULL;
int alloc = 0;
APE_PARAMS_INIT();
if (domain == NULL) {
send_error(callbacki->call_user, "NO_DOMAIN", "201", callbacki->g_ape);
} else {
char *autodom;
if (strcmp(domain, "auto") == 0 && (autodom = JSTR(domain)) != NULL) {
domain = autodom;
#if 0
/* http://geekandpoke.typepad.com/.a/6a00d8341d3df553ef0120a6d65b8a970b-pi */
struct _http_header_line *hlines;
for (hlines = callbacki->client->http.hlines; hlines != NULL; hlines = hlines->next) {
if (strcasecmp(hlines->key.val, "host") == 0) {
char *loc;
char *newdom = xmalloc(sizeof(char) * (hlines->value.len + 1));
memset(newdom, '\0', hlines->value.len + 1);
if ((loc = strrchr(hlines->value.val, '.')) != NULL) {
int i, pos = 0;
for (i = 0; i < hlines->value.len; i++, pos++) {
newdom[pos] = hlines->value.val[i];
if (newdom[pos] == ':') {
newdom[pos] = '\0';
break;
}
if (hlines->value.val[i] == '.' && &hlines->value.val[i] < loc) {
pos = -1;
}
}
newdom[pos] = '\0';
domain = newdom;
alloc = 1;
}
}
}
#endif
}
sendf(callbacki->client->fd, callbacki->g_ape, "%s<html>\n<head>\n\t<script>\n\t\tdocument.domain=\"%s\"\n\t</script>\n", HEADER_DEFAULT, domain);
if (alloc) {
free(domain);
}
JFOREACH(scripts, script) {
sendf(callbacki->client->fd, callbacki->g_ape, "\t<script type=\"text/javascript\" src=\"%s\"></script>\n", script);
}
sendbin(callbacki->client->fd, "</head>\n<body>\n</body>\n</html>", 30, 0, callbacki->g_ape);
}
ulong board_init_f_alloc_reserve(ulong top)
{
/* Reserve early malloc arena */
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
top -= CONFIG_VAL(SYS_MALLOC_F_LEN);
#endif
/* LAST : reserve GD (rounded up to a multiple of 16 bytes) */
top = rounddown(top-sizeof(struct global_data), 16);
return top;
}
static int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
bd_t *bd = gd->bd;
print_num("arch_number", bd->bi_arch_number);
print_bi_boot_params(bd);
print_bi_dram(bd);
#ifdef CONFIG_SYS_MEM_RESERVE_SECURE
if (gd->arch.secure_ram & MEM_RESERVE_SECURE_SECURED) {
print_num("Secure ram",
gd->arch.secure_ram & MEM_RESERVE_SECURE_ADDR_MASK);
}
#endif
#ifdef CONFIG_RESV_RAM
if (gd->arch.resv_ram)
print_num("Reserved ram", gd->arch.resv_ram);
#endif
#if defined(CONFIG_CMD_NET) && !defined(CONFIG_DM_ETH)
print_eths();
#endif
print_baudrate();
#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
print_num("TLB addr", gd->arch.tlb_addr);
#endif
print_num("relocaddr", gd->relocaddr);
print_num("reloc off", gd->reloc_off);
print_num("irq_sp", gd->irq_sp); /* irq stack pointer */
print_num("sp start ", gd->start_addr_sp);
#if defined(CONFIG_LCD) || defined(CONFIG_VIDEO)
print_num("FB base ", gd->fb_base);
#endif
/*
* TODO: Currently only support for davinci SOC's is added.
* Remove this check once all the board implement this.
*/
#ifdef CONFIG_CLOCKS
printf("ARM frequency = %ld MHz\n", gd->bd->bi_arm_freq);
printf("DSP frequency = %ld MHz\n", gd->bd->bi_dsp_freq);
printf("DDR frequency = %ld MHz\n", gd->bd->bi_ddr_freq);
#endif
#ifdef CONFIG_BOARD_TYPES
printf("Board Type = %ld\n", gd->board_type);
#endif
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
printf("Early malloc usage: %lx / %x\n", gd->malloc_ptr,
CONFIG_VAL(SYS_MALLOC_F_LEN));
#endif
if (gd->fdt_blob)
print_num("fdt_blob", (ulong)gd->fdt_blob);
return 0;
}
unsigned int cmd_script(callbackp *callbacki)
{
char *domain = CONFIG_VAL(Server, domain, callbacki->g_ape->srv);
if (domain == NULL) {
send_error(callbacki->call_user, "NO_DOMAIN", "201", callbacki->g_ape);
} else {
int i;
sendf(callbacki->fdclient, callbacki->g_ape, "%s<html>\n<head>\n\t<script>\n\t\tdocument.domain=\"%s\"\n\t</script>\n", HEADER, domain);
for (i = 1; i <= callbacki->nParam; i++) {
sendf(callbacki->fdclient, callbacki->g_ape, "\t<script type=\"text/javascript\" src=\"%s\"></script>\n", callbacki->param[i]);
}
sendbin(callbacki->fdclient, "</head>\n<body>\n</body>\n</html>", 30, callbacki->g_ape);
}
return (FOR_NOTHING);
}
void transport_start(acetables *g_ape)
{
char *eval_func = CONFIG_VAL(JSONP, eval_func, g_ape->srv);
int len = strlen(eval_func);
if (len) {
g_ape->transports.jsonp.properties.padding.left.val = xmalloc(sizeof(char) * (len + 3));
strcpy(g_ape->transports.jsonp.properties.padding.left.val, eval_func);
strcat(g_ape->transports.jsonp.properties.padding.left.val, "('");
g_ape->transports.jsonp.properties.padding.left.len = len+2;
g_ape->transports.jsonp.properties.padding.right.val = xstrdup("')");
g_ape->transports.jsonp.properties.padding.right.len = 2;
} else {
g_ape->transports.jsonp.properties.padding.left.val = NULL;
}
g_ape->transports.xhrstreaming.properties.padding.left.val = NULL;
g_ape->transports.xhrstreaming.properties.padding.left.len = 0;
g_ape->transports.xhrstreaming.properties.padding.right.val = xstrdup("\n\n");
g_ape->transports.xhrstreaming.properties.padding.right.len = 2;
g_ape->transports.sse.properties.padding.left.val = xstrdup("Event: ape-event\nData: ");
g_ape->transports.sse.properties.padding.left.len = 24;
g_ape->transports.sse.properties.padding.right.val = xstrdup("\n\n");
g_ape->transports.sse.properties.padding.right.len = 2;
g_ape->transports.websocket.properties.padding.left.val = xstrdup("\x00");
g_ape->transports.websocket.properties.padding.left.len = 1;
g_ape->transports.websocket.properties.padding.right.val = xstrdup("\xFF");
g_ape->transports.websocket.properties.padding.right.len = 1;
g_ape->transports.websocket_ietf.properties.padding.left.val = NULL;
g_ape->transports.websocket_ietf.properties.padding.left.len = 0;
g_ape->transports.websocket_ietf.properties.padding.right.val = NULL;
g_ape->transports.websocket_ietf.properties.padding.right.len = 0;
}
static int uncompress_blob(const void *src, ulong sz_src, void **dstp)
{
size_t sz_out = CONFIG_SPL_MULTI_DTB_FIT_UNCOMPRESS_SZ;
ulong sz_in = sz_src;
void *dst;
int rc;
if (CONFIG_IS_ENABLED(GZIP))
if (gzip_parse_header(src, sz_in) < 0)
return -1;
if (CONFIG_IS_ENABLED(LZO))
if (!lzop_is_valid_header(src))
return -EBADMSG;
if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) {
dst = malloc(sz_out);
if (!dst) {
puts("uncompress_blob: Unable to allocate memory\n");
return -ENOMEM;
}
} else {
# if CONFIG_IS_ENABLED(MULTI_DTB_FIT_USER_DEFINED_AREA)
dst = (void *)CONFIG_VAL(MULTI_DTB_FIT_USER_DEF_ADDR);
# else
return -ENOTSUPP;
# endif
}
if (CONFIG_IS_ENABLED(GZIP))
rc = gunzip(dst, sz_out, (u8 *)src, &sz_in);
else if (CONFIG_IS_ENABLED(LZO))
rc = lzop_decompress(src, sz_in, dst, &sz_out);
if (rc < 0) {
/* not a valid compressed blob */
puts("uncompress_blob: Unable to uncompress\n");
if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC))
free(dst);
return -EBADMSG;
}
*dstp = dst;
return 0;
}
static int spl_common_init(bool setup_malloc)
{
int ret;
debug("spl_early_init()\n");
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
if (setup_malloc) {
#ifdef CONFIG_MALLOC_F_ADDR
gd->malloc_base = CONFIG_MALLOC_F_ADDR;
#endif
gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN);
gd->malloc_ptr = 0;
}
#endif
ret = bootstage_init(true);
if (ret) {
debug("%s: Failed to set up bootstage: ret=%d\n", __func__,
ret);
return ret;
}
bootstage_mark_name(BOOTSTAGE_ID_START_SPL, "spl");
if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
ret = fdtdec_setup();
if (ret) {
debug("fdtdec_setup() returned error %d\n", ret);
return ret;
}
}
if (CONFIG_IS_ENABLED(DM)) {
bootstage_start(BOOTSTATE_ID_ACCUM_DM_SPL, "dm_spl");
/* With CONFIG_SPL_OF_PLATDATA, bring in all devices */
ret = dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA));
bootstage_accum(BOOTSTATE_ID_ACCUM_DM_SPL);
if (ret) {
debug("dm_init_and_scan() returned error %d\n", ret);
return ret;
}
}
return 0;
}
int main(int argc, char **argv)
{
apeconfig *srv;
int random, im_r00t = 0, pidfd = 0, serverfd;
unsigned int getrandom = 0, ct_id;
const char *pidfile = NULL;
char *confs_path = NULL;
struct _fdevent fdev;
char cfgfile[513] = APE_CONFIG_FILE;
acetables *g_ape;
if (argc > 1 && strcmp(argv[1], "--version") == 0) {
printf("\n AJAX Push Engine Server %s - (C) Anthony Catel <*****@*****.**>\n http://www.ape-project.org/\n\n", _VERSION);
return 0;
}
if (argc > 1 && strcmp(argv[1], "--help") == 0) {
printf("\n AJAX Push Engine Server %s - (C) Anthony Catel <*****@*****.**>\n http://www.ape-project.org/\n", _VERSION);
printf("\n usage: aped [options]\n\n");
printf(" Options:\n --help : Display this help\n --version : Show version number\n --cfg <config path>: Load a specific config file (default is %s)\n\n", cfgfile);
return 0;
} else if (argc > 2 && strcmp(argv[1], "--cfg") == 0) {
memset(cfgfile, 0, 513);
strncpy(cfgfile, argv[2], 512);
confs_path = get_path(cfgfile);
} else if (argc > 1) {
printf("\n AJAX Push Engine Server %s - (C) Anthony Catel <*****@*****.**>\n http://www.ape-project.org/\n\n", _VERSION);
printf(" Unknown parameters - check \"aped --help\"\n\n");
return 0;
}
if (NULL == (srv = ape_config_load(cfgfile))) {
printf("\nExited...\n\n");
exit(1);
}
if (getuid() == 0) {
im_r00t = 1;
}
signal(SIGINT, &signal_handler);
signal(SIGTERM, &signal_handler);
if (VTICKS_RATE < 1) {
printf("[ERR] TICKS_RATE cant be less than 1\n");
return 0;
}
random = open("/dev/urandom", O_RDONLY);
if (!random) {
printf("Cannot open /dev/urandom... exiting\n");
return 0;
}
read(random, &getrandom, 3);
srand(getrandom);
close(random);
g_ape = xmalloc(sizeof(*g_ape));
g_ape->basemem = 1; // set 1 for testing if growup works
g_ape->srv = srv;
g_ape->confs_path = confs_path;
g_ape->is_daemon = 0;
ape_log_init(g_ape);
fdev.handler = EVENT_UNKNOWN;
#ifdef USE_EPOLL_HANDLER
fdev.handler = EVENT_EPOLL;
#endif
#ifdef USE_KQUEUE_HANDLER
fdev.handler = EVENT_KQUEUE;
#endif
g_ape->co = xmalloc(sizeof(*g_ape->co) * g_ape->basemem);
memset(g_ape->co, 0, sizeof(*g_ape->co) * g_ape->basemem);
g_ape->bad_cmd_callbacks = NULL;
g_ape->bufout = xmalloc(sizeof(struct _socks_bufout) * g_ape->basemem);
g_ape->timers.timers = NULL;
g_ape->timers.ntimers = 0;
g_ape->events = &fdev;
if (events_init(g_ape, &g_ape->basemem) == -1) {
printf("Fatal error: APE compiled without an event handler... exiting\n");
return 0;
};
serverfd = servers_init(g_ape);
ape_log(APE_INFO, __FILE__, __LINE__, g_ape,
"APE starting up - pid : %i", getpid());
if (strcmp(CONFIG_VAL(Server, daemon, srv), "yes") == 0 && (pidfile = CONFIG_VAL(Server, pid_file, srv)) != NULL) {
if ((pidfd = open(pidfile, O_TRUNC | O_WRONLY | O_CREAT, 0655)) == -1) {
ape_log(APE_WARN, __FILE__, __LINE__, g_ape,
"Cant open pid file : %s", CONFIG_VAL(Server, pid_file, srv));
}
}
if (im_r00t) {
struct group *grp = NULL;
struct passwd *pwd = NULL;
if (inc_rlimit(atoi(CONFIG_VAL(Server, rlimit_nofile, srv))) == -1) {
ape_log(APE_WARN, __FILE__, __LINE__, g_ape,
"Cannot set the max filedescriptos limit (setrlimit) %s", strerror(errno));
}
/* Set uid when uid section exists */
if (ape_config_get_section(srv, "uid")) {
/* Get the user information (uid section) */
if ((pwd = getpwnam(CONFIG_VAL(uid, user, srv))) == NULL) {
ape_log(APE_ERR, __FILE__, __LINE__, g_ape,
"Can\'t find username %s", CONFIG_VAL(uid, user, srv));
return -1;
}
if (pwd->pw_uid == 0) {
ape_log(APE_ERR, __FILE__, __LINE__, g_ape,
"%s uid can\'t be 0", CONFIG_VAL(uid, user, srv));
return -1;
}
/* Get the group information (uid section) */
if ((grp = getgrnam(CONFIG_VAL(uid, group, srv))) == NULL) {
printf("[ERR] Can\'t find group %s\n", CONFIG_VAL(uid, group, srv));
ape_log(APE_ERR, __FILE__, __LINE__, g_ape,
"Can\'t find group %s", CONFIG_VAL(uid, group, srv));
return -1;
}
if (grp->gr_gid == 0) {
ape_log(APE_ERR, __FILE__, __LINE__, g_ape,
"%s gid can\'t be 0", CONFIG_VAL(uid, group, srv));
return -1;
}
setgid(grp->gr_gid);
setgroups(0, NULL);
initgroups(CONFIG_VAL(uid, user, srv), grp->gr_gid);
setuid(pwd->pw_uid);
}
} else {
printf("[WARN] You have to run \'aped\' as root to increase r_limit\n");
ape_log(APE_WARN, __FILE__, __LINE__, g_ape,
"You have to run \'aped\' as root to increase r_limit");
}
if (strcmp(CONFIG_VAL(Server, daemon, srv), "yes") == 0) {
ape_log(APE_INFO, __FILE__, __LINE__, g_ape,
"Starting daemon");
ape_daemon(pidfd, g_ape);
events_reload(g_ape->events);
events_add(g_ape->events, serverfd, EVENT_READ);
}
if (!g_ape->is_daemon) {
printf(" _ ___ ___ \n");
printf(" /_\\ | _ \\ __|\n");
printf(" / _ \\| _/ _| \n");
printf("/_/ \\_\\_| |___|\nAJAX Push Engine\n\n");
printf("Bind on port %i\n\n", atoi(CONFIG_VAL(Server, port, srv)));
printf("Version : %s\n", _VERSION);
printf("Build : %s %s\n", __DATE__, __TIME__);
printf("Author : Weelya ([email protected])\n\n");
}
signal(SIGPIPE, SIG_IGN);
ape_dns_init(g_ape);
g_ape->cmd_hook.head = NULL;
g_ape->cmd_hook.foot = NULL;
g_ape->hSessid = hashtbl_init();
g_ape->hChannel = hashtbl_init();
g_ape->hPubid = hashtbl_init();
g_ape->proxy.list = NULL;
g_ape->proxy.hosts = NULL;
g_ape->hCallback = hashtbl_init();
g_ape->uHead = NULL;
g_ape->cHead = NULL;
g_ape->nConnected = 0;
g_ape->plugins = NULL;
g_ape->properties = NULL;
ct_id = add_ticked(check_timeout, g_ape)->identifier;
do_register(g_ape);
transport_start(g_ape);
findandloadplugin(g_ape);
server_is_running = 1;
server_is_shutdowning = 0;
/* Starting Up */
sockroutine(g_ape); /* loop */
/* Shutdown */
if (pidfile != NULL) {
unlink(pidfile);
}
free(confs_path);
ape_dns_free(g_ape);
del_timer_identifier(ct_id, g_ape);
events_free(g_ape);
transport_free(g_ape);
hashtbl_free(g_ape->hSessid, 0);
hashtbl_free(g_ape->hChannel, 0);
hashtbl_free(g_ape->hPubid, 0);
do_unregister(g_ape);
hashtbl_free(g_ape->hCallback, 1);
ape_config_free(srv);
int i;
for (i = 0; i < g_ape->basemem; i++) {
if (g_ape->co[i] != NULL) {
close_socket(i, g_ape);
free(g_ape->co[i]);
}
}
free(g_ape->co);
free(g_ape->bufout);
free_all_hook_cmd(g_ape);
free_all_plugins(g_ape);
free(g_ape);
return 0;
}
subuser *checkrecv(char *pSock, ape_socket *client, acetables *g_ape, char *ip_client)
{
unsigned int op;
unsigned int isget = 0;
subuser *user = NULL;
int local = (strcmp(ip_client, CONFIG_VAL(Server, ip_local, g_ape->srv)) == 0);
clientget *cget = xmalloc(sizeof(*cget));
if (strlen(pSock) < 3 || (local && getqueryip(pSock, cget->ip_get) == 0)) { // get query IP (from htaccess)
free(cget);
shutdown(client->fd, 2);
return NULL;
}
if (!local) {
strncpy(cget->ip_get, ip_client, 16); // get real IP (from socket)
}
cget->client = client;
gethost(pSock, cget->host);
if (strncasecmp(pSock, "GET", 3) == 0) {
if (!fixpacket(pSock, 0) || (cget->get = getfirstparam(pSock, (local ? '&' : '?'))) == NULL) {
free(cget);
shutdown(client->fd, 2);
return NULL;
} else {
isget = 1;
}
} else if (strncasecmp(pSock, "POST", 4) == 0) {
if ((cget->get = getpost(pSock)) == NULL) {
free(cget);
shutdown(client->fd, 2);
return NULL;
}
} else {
free(cget);
shutdown(client->fd, 2);
return NULL;
}
fixpacket(cget->get, 1);
if (isget) {
urldecode(cget->get);
}
op = checkcmd(cget, gettransport(pSock), &user, g_ape);
switch (op) {
case CONNECT_SHUTDOWN:
shutdown(client->fd, 2);
break;
case CONNECT_KEEPALIVE:
break;
}
free(cget);
return user;
}
/*
* This module records the progress of boot and arbitrary commands, and
* permits accurate timestamping of each.
*/
#include <common.h>
#include <linux/libfdt.h>
#include <malloc.h>
#include <linux/compiler.h>
DECLARE_GLOBAL_DATA_PTR;
enum {
RECORD_COUNT = CONFIG_VAL(BOOTSTAGE_RECORD_COUNT),
};
struct bootstage_record {
ulong time_us;
uint32_t start_us;
const char *name;
int flags; /* see enum bootstage_flags */
enum bootstage_id id;
};
struct bootstage_data {
uint rec_count;
uint next_id;
struct bootstage_record record[RECORD_COUNT];
};
