static void
Cw_handler(lcb_sockdata_t *sd, int status, void *arg)
{
lcbio__EASYRB *erb = arg;
lcbio_CTX *ctx = erb->parent;
(void)sd;
ctx->npending--;
if (!ctx->output) {
ctx->output = erb;
ringbuffer_reset(&erb->rb);
} else {
ringbuffer_destruct(&erb->rb);
free(erb);
}
if (ctx->state == ES_ACTIVE && status) {
invoke_entered_errcb(ctx, convert_lcberr(ctx, LCBIO_IOERR));
}
if (ctx->state != ES_ACTIVE && ctx->npending == 0) {
free_ctx(ctx);
}
}
static void
Cr_handler(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
{
lcbio_CTX *ctx = arg;
sd->is_reading = 0;
ctx->npending--;
if (ctx->state == ES_ACTIVE) {
if (nr > 0) {
unsigned total;
rdb_rdend(&ctx->ior, nr);
total = rdb_get_nused(&ctx->ior);
if (total >= ctx->rdwant) {
invoke_read_cb(ctx, total);
}
lcbio_ctx_schedule(ctx);
} else {
lcb_error_t err =
convert_lcberr(ctx, nr ? LCBIO_SHUTDOWN : LCBIO_IOERR);
ctx->rdwant = 0;
invoke_entered_errcb(ctx, err);
}
}
if (ctx->state != ES_ACTIVE && ctx->npending == 0) {
free_ctx(ctx);
}
}
/*
MOVIE / ALTERNATIVE TITLES
*/
tmdb_movie_t *tmdb_movie_alt_titles(const char *movie_id, const char *country)
{
int result;
char *url_str;
net_data_t data;
tmdb_request_ctx_t ctx;
tmdb_movie_t *info = NULL;
init_data_chunk(&data);
memset(&ctx, 0, sizeof(tmdb_request_ctx_t));
tmdb_ctx_set(&ctx, API_URL_F, NULL);
tmdb_ctx_set(&ctx, API_HEADER_F, NULL);
tmdb_ctx_set(&ctx, API_KEY_F, NULL);
ctx.request_type.type = MOVIE_ALT_TITLES;
tmdb_ctx_set(&ctx, MOVIE_ID, movie_id);
if (country)
tmdb_ctx_set(&ctx, COUNTRY, country);
url_str = tmdb_get_url_from_ctx(&ctx);
result = nethelper_get(url_str, API_HEADER, &data);
free(url_str);
free_ctx(&ctx);
if (!result) {
header_process(&data);
body_process(&data, MOVIE_ALT_NUM_TOKENS,
movie_alt_parse, &info);
}
free_data_chunk(&data);
return info;
}
/*
MOVIE / GET_TRAILERS
*/
tmdb_movie_trailers_t *tmdb_movie_trailers(const char *movie_id)
{
int result;
char *url_str;
net_data_t data;
tmdb_request_ctx_t ctx;
tmdb_movie_trailers_t *movie_trailers = NULL;
init_data_chunk(&data);
memset(&ctx, 0, sizeof(tmdb_request_ctx_t));
tmdb_ctx_set(&ctx, API_URL_F, NULL);
tmdb_ctx_set(&ctx, API_HEADER_F, NULL);
tmdb_ctx_set(&ctx, API_KEY_F, NULL);
ctx.request_type.type = MOVIE_TRAILERS;
tmdb_ctx_set(&ctx, MOVIE_ID, movie_id);
url_str = tmdb_get_url_from_ctx(&ctx);
result = nethelper_get(url_str, API_HEADER, &data);
free(url_str);
free_ctx(&ctx);
if (!result) {
header_process(&data);
body_process(&data, MOVIE_TRAILERS_NUM_TOKENS,
movie_trailers_parse, &movie_trailers);
}
free_data_chunk(&data);
return movie_trailers;
}
/*
GENRE / LIST
*/
tmdb_genre_t *tmdb_genre_list(const char *language)
{
int result;
char *url_str;
net_data_t data;
tmdb_request_ctx_t ctx;
tmdb_genre_t *genres = NULL;
init_data_chunk(&data);
memset(&ctx, 0, sizeof(tmdb_request_ctx_t));
tmdb_ctx_set(&ctx, API_URL_F, NULL);
tmdb_ctx_set(&ctx, API_HEADER_F, NULL);
tmdb_ctx_set(&ctx, API_KEY_F, NULL);
ctx.request_type.type = GENRE_LIST;
if (language)
tmdb_ctx_set(&ctx, LANGUAGE, language);
url_str = tmdb_get_url_from_ctx(&ctx);
result = nethelper_get(url_str, API_HEADER, &data);
free(url_str);
free_ctx(&ctx);
if (!result) {
header_process(&data);
body_process(&data, GENRE_LIST_NUM_TOKENS,
genre_list_parse, &genres);
}
free_data_chunk(&data);
return genres;
}
static int stop_record_alsa(void *context) {
pthread_t k;
rec_ctx *ctx = (rec_ctx *) context;
#ifdef DEBUG_CONTEXTS
int ctx_idx;
#endif
if(!ctx) {
log_err("zero context");
return 0;
}
#ifdef DEBUG_CONTEXTS
for(ctx_idx = 0; ctx_idx < MAX_CTX; ctx_idx++) if(contexts[ctx_idx] == ctx) break;
if(ctx_idx == MAX_CTX) {
log_err("no such context");
return 0;
}
contexts[ctx_idx] = 0;
#endif
pthread_mutex_lock(&mutty);
log_info("stop_record (ctx=%p)", ctx);
ctx->running = 0;
pthread_join(ctx->rec,0);
log_info("recording thread stopped");
if(ctx->snd) snd_pcm_close(ctx->snd);
free_ctx(ctx);
pthread_mutex_unlock(&mutty);
return 1;
}
static int
E_free_detached(lcbio_CTX *ctx)
{
if (ctx->state == ES_DETACHED) {
free_ctx(ctx);
return 1;
}
return 0;
}
void
lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg,
lcbio_CTXDTOR_cb dtor, void *dtor_arg)
{
unsigned oldrc;
ctx->state = ES_DETACHED;
assert(ctx->sock);
if (ctx->event) {
deactivate_watcher(ctx);
IOT_V0EV(CTX_IOT(ctx)).destroy(IOT_ARG(CTX_IOT(ctx)), ctx->event);
ctx->event = NULL;
}
if (ctx->as_err) {
lcbio_timer_destroy(ctx->as_err);
ctx->as_err = NULL;
}
oldrc = ctx->sock->refcount;
lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying. PND=%d,ENT=%d,SORC=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered, oldrc);
if (cb) {
int reusable =
ctx->npending == 0 && /* no pending events */
ctx->err == LCB_SUCCESS && /* no socket errors */
ctx->rdwant == 0 && /* no expected input */
ctx->wwant == 0 && /* no expected output */
(ctx->output == NULL || ctx->output->rb.nbytes == 0);
cb(ctx->sock, reusable, arg);
}
if (oldrc == ctx->sock->refcount) {
lcbio_shutdown(ctx->sock);
}
if (ctx->output) {
ringbuffer_destruct(&ctx->output->rb);
free(ctx->output);
ctx->output = NULL;
}
ctx->fd = INVALID_SOCKET;
ctx->sd = NULL;
if (dtor) {
ctx->data = dtor_arg;
ctx->procs.cb_flush_ready = dtor;
} else {
ctx->procs.cb_flush_ready = NULL;
}
if (ctx->npending == 0 && ctx->entered == 0) {
free_ctx(ctx);
}
}
static void *start_record_alsa(char *file) {
pthread_attr_t attr;
const char *folder = 0;
struct stat st;
rec_ctx *ctx = 0;
#ifdef DEBUG_CONTEXTS
int ctx_idx;
#endif
pthread_mutex_lock(&mutty);
log_info("start_record");
#ifdef DEBUG_CONTEXTS
for(ctx_idx = 0; ctx_idx < MAX_CTX; ctx_idx++) if(!contexts[ctx_idx]) break;
if(ctx_idx == MAX_CTX) {
log_err("no free contexts");
return 0;
}
#endif
ctx = (rec_ctx *) calloc(sizeof(rec_ctx),1);
if(!ctx) {
log_err("no memory!");
goto fail;
}
ctx->fd_out = -1;
ctx->cur_file = (char *) malloc(strlen(file)+1);
if(!ctx->cur_file) {
log_err("no memory!");
goto fail;
}
strcpy(ctx->cur_file,file);
/* Open/configure the device, and open output file */
if(!init_recording(ctx)) goto fail;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_create(&ctx->rec,&attr,record,ctx);
log_info("started recording to %s (ctx=%p)", file, ctx);
pthread_attr_destroy(&attr);
pthread_mutex_unlock(&mutty);
#ifdef DEBUG_CONTEXTS
contexts[ctx_idx] = ctx;
#endif
return ctx;
fail:
free_ctx(ctx);
pthread_mutex_unlock(&mutty);
return 0;
}
/*
* Force a screen update.
*/
void term_update(void) {
Context ctx;
ctx = get_ctx();
if (ctx) {
do_paint (ctx, TRUE);
free_ctx (ctx);
nl_count = 0;
scroll_heuristic = 0;
}
}
void server()
{
ctx_t *ctx = make_ctx(SIZE);
ctx->sock = make_server_socket();
ctx->who = SERVER;
/* both delay */
ctx->mili = unit;
do_server_run(ctx);
/* server delay */
do_server_run(ctx);
/* client delay */
ctx->mili = 0;
do_server_run(ctx);
shutdown(ctx->sock, 0);
free_ctx(ctx);
return;
}
void client()
{
ctx_t *ctx = make_ctx(SIZE);
ctx->sock = make_client_socket();
ctx->who = CLIENT;
/* both delay */
ctx->mili = unit;
do_client_run(ctx);
/* server delay */
ctx->mili = 0;
do_client_run(ctx);
/* client delay */
ctx->mili = unit;
do_client_run(ctx);
shutdown(ctx->sock, 0);
free_ctx(ctx);
return;
}
/*
SEARCH / COMPANY
*/
tmdb_company_t *tmdb_search_company(const char *name)
{
int result;
char *url_str;
char *esc_name;
net_data_t data;
tmdb_request_ctx_t ctx;
tmdb_company_t *companies = NULL;
init_data_chunk(&data);
esc_name = escaped_string(name);
memset(&ctx, 0, sizeof(tmdb_request_ctx_t));
tmdb_ctx_set(&ctx, API_URL_F, NULL);
tmdb_ctx_set(&ctx, API_HEADER_F, NULL);
tmdb_ctx_set(&ctx, API_KEY_F, NULL);
ctx.request_type.type = SEARCH_COMPANY;
tmdb_ctx_set(&ctx, QUERY, esc_name);
url_str = tmdb_get_url_from_ctx(&ctx);
result = nethelper_get(url_str, API_HEADER, &data);
free(url_str);
free_ctx(&ctx);
free(esc_name);
if (!result) {
header_process(&data);
body_process(&data, SEARCH_COMPANY_NUM_TOKENS,
company_search_parse, &companies);
}
free_data_chunk(&data);
return companies;
}
/*
COLLECTION / INFO
*/
tmdb_collection_t *tmdb_collection_info(const char *collection_id,
const char *language)
{
int result;
char *url_str;
net_data_t data;
tmdb_request_ctx_t ctx;
tmdb_collection_t *collection_info = NULL;
init_data_chunk(&data);
memset(&ctx, 0, sizeof(tmdb_request_ctx_t));
tmdb_ctx_set(&ctx, API_URL_F, NULL);
tmdb_ctx_set(&ctx, API_HEADER_F, NULL);
tmdb_ctx_set(&ctx, API_KEY_F, NULL);
ctx.request_type.type = COLLECTION;
tmdb_ctx_set(&ctx, COLLECTION_ID, collection_id);
if (language)
tmdb_ctx_set(&ctx, LANGUAGE, language);
url_str = tmdb_get_url_from_ctx(&ctx);
result = nethelper_get(url_str, API_HEADER, &data);
free(url_str);
free_ctx(&ctx);
if (!result) {
header_process(&data);
body_process(&data, COLLECTION_INFO_NUM_TOKENS,
collection_info_parse, &collection_info);
}
free_data_chunk(&data);
return collection_info;
}
int
demonize(ctx * Ctx){
int fd;
/* int i;
struct rlimit rl;
if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
perror("can't get file limit");
if (rl.rlim_max == RLIM_INFINITY)
rl.rlim_max = 1024;
for (i = 0; i < rl.rlim_max; i++)
close(i);
*/
switch (fork()) {
case -1:
perror("demonize fork failed");
return -1;
case 0:
break;
default:
free_ctx(Ctx);
exit(0);
}
int pid = getpid();
if (setsid() == -1) {
// tolog(Ctx, LOG_ERROR, "setsid() failed");
perror("setsid() failed");
return -1;
}
umask(0);
fd = open("/dev/null", O_RDWR);
if (fd == -1) {
// tolog("open(\"/dev/null\") failed", LOG_ERROR, Ctx);
perror("open(\"/dev/null\") failed");
return -1;
}
if (dup2(fd, STDIN_FILENO) == -1) {
// tolog("dup2(STDIN) failed", LOG_ERROR, Ctx);
perror("dup2(STDIN) failed");
return -1;
}
if (dup2(fd, STDOUT_FILENO) == -1) {
// tolog("dup2(STDOUT) failed", LOG_ERROR, Ctx);
perror("dup2(STDOUT) failed");
return -1;
}
if (dup2(fd, STDERR_FILENO) == -1) {
tolog(Ctx, LOG_ERROR, "dup2(STDERR) failed", "");
// logs << "dup2(STDERR) failed";
return -1;
}
if (fd > STDERR_FILENO) {
if (close(fd) == -1) {
// tolog("close(fd) failed", LOG_ERROR, Ctx);
perror("close(fd) failed");
return -1;
}
}
return pid;
}
int main(int argc, char *argv[])
{
signed char c;
struct ctx_t *ctx;
static struct option longopts[] = {
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"infile", required_argument, 0, 'f'},
{"outfile", required_argument, 0, 'F'},
{"outtype", required_argument, 0, 'o'},
{"gsw230", no_argument, 0, '2'},
{0, 0, 0, 0}
};
ctx = init_ctx();
if (ctx == NULL)
return 1;
#ifdef WIN32
#ifdef _MSC_VER
_set_output_format(_TWO_DIGIT_EXPONENT);
#else
putenv("PRINTF_EXPONENT_DIGITS=2");
#endif
#endif
while ((c = getopt_long(argc, argv, "vh?f:F:o:2",longopts,NULL)) != -1) {
switch (c) {
case 'f':
if (set_file(&ctx->opts.infile, optarg) != 0) {
free_ctx(ctx);
return 1;
}
break;
case 'F':
if (set_file(&ctx->opts.outfile, optarg) != 0) {
free_ctx(ctx);
return 1;
}
break;
case 'o':
if (strcmp(optarg, "nmea") == 0) {
ctx->opts.output_type = OUTPUT_NMEA;
}else if (strcmp(optarg, "dump") == 0) {
ctx->opts.output_type = OUTPUT_DUMP;
}else if (strcmp(optarg, "rinex") == 0) {
ctx->opts.output_type = OUTPUT_RINEX;
}else if (strcmp(optarg, "rinex-nav") == 0) {
ctx->opts.output_type = OUTPUT_RINEX_NAV;
}else if (strcmp(optarg, "rtcm") == 0) {
ctx->opts.output_type = OUTPUT_RTCM;
}else {
fputs("Wrong output type\n", stderr);
return 1;
}
break;
case '2':
ctx->opts.gsw230_byte_order = 1;
break;
case 'v':
version();
free_ctx(ctx);
exit(0);
break;
default:
help();
free_ctx(ctx);
exit(0);
break;
}
}
argc -= optind;
argv += optind;
/* infile */
if (ctx->opts.infile != NULL) {
ctx->in.fd = open(ctx->opts.infile, O_RDONLY
#ifdef O_BINARY
| O_BINARY
#endif
);
if (ctx->in.fd < 0) {
perror(NULL);
free_ctx(ctx);
return 1;
}
}else
ctx->in.fd = STDIN_FILENO;
/* outfile */
if (ctx->opts.outfile != NULL) {
ctx->outfh = fopen(ctx->opts.outfile,
#ifdef WIN32
"wb"
#else
"w"
#endif
);
if (ctx->outfh == NULL) {
perror(NULL);
free_ctx(ctx);
return 1;
}
}else
ctx->outfh = stdout;
/* output_type */
switch (ctx->opts.output_type) {
case OUTPUT_NMEA:
ctx->dump_f = &output_nmea;
break;
case OUTPUT_RINEX:
ctx->dump_f = &output_rinex;
ctx->user_ctx = new_rinex_ctx(argc, argv, ctx->opts.gsw230_byte_order);
if (ctx->user_ctx == NULL) {
perror(NULL);
free_ctx(ctx);
return 1;
}
break;
case OUTPUT_RINEX_NAV:
ctx->dump_f = &output_rinex_nav;
ctx->user_ctx = new_rinex_nav_ctx(argc, argv);
if (ctx->user_ctx == NULL) {
perror(NULL);
free_ctx(ctx);
return 1;
}
break;
case OUTPUT_RTCM:
ctx->dump_f = &output_rtcm;
ctx->user_ctx = new_rtcm_ctx(argc, argv, ctx->opts.gsw230_byte_order);
setvbuf(ctx->outfh, NULL, _IONBF, 0);
if (ctx->user_ctx == NULL) {
perror(NULL);
free_ctx(ctx);
return 1;
}
break;
case OUTPUT_DUMP:
default:
output_dump_use_gsw230_byte_order = ctx->opts.gsw230_byte_order;
ctx->dump_f = &output_dump;
break;
}
process(ctx);
switch (ctx->opts.output_type) {
case OUTPUT_RINEX:
free_rinex_ctx(ctx->user_ctx);
break;
case OUTPUT_RINEX_NAV:
free_rinex_nav_ctx(ctx->user_ctx);
break;
case OUTPUT_RTCM:
free_rtcm_ctx(ctx->user_ctx);
break;
default:
break;
}
free_ctx(ctx);
return 0;
}
