/**
* \brief Input plugin "destructor".
*
* \param[in,out] config plugin_info structure
* \return 0 on success and config is changed to NULL, nonzero else.
*/
int input_close(void **config)
{
int ret;
struct plugin_conf *conf = (struct plugin_conf*) *config;
struct input_info_list *info_list;
/* close socket */
int sock = ((struct plugin_conf*) *config)->socket;
if ((ret = close(sock)) == -1) {
MSG_ERROR(msg_module, "Cannot close socket: %s", strerror(errno));
}
/* free input_info list */
while (conf->info_list) {
info_list = conf->info_list->next;
free(conf->info_list);
conf->info_list = info_list;
}
/* free configuration strings */
if (conf->info.template_life_time != NULL) {
free(conf->info.template_life_time);
}
if (conf->info.template_life_packet != NULL) {
free(conf->info.template_life_packet);
}
if (conf->info.options_template_life_time != NULL) {
free(conf->info.options_template_life_time);
}
if (conf->info.options_template_life_packet != NULL) {
free(conf->info.options_template_life_packet);
}
/* free allocated structures */
free(*config);
convert_close();
MSG_INFO(msg_module, "All allocated resources have been freed");
return 0;
}
/**
* @fn int search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
*
* search: search specified function
*
* @param[in] pattern search pattern
* @param[in] root root of source tree
* @param[in] cwd current directory
* @param[in] dbpath database directory
* @param[in] db #GTAGS,#GRTAGS,#GSYMS
* @return count of output lines
*/
int
search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
{
CONVERT *cv;
int count = 0;
GTOP *gtop;
GTP *gtp;
int flags = 0;
start_output();
/*
* open tag file.
*/
gtop = gtags_open(dbpath, root, db, GTAGS_READ, debug ? GTAGS_DEBUG : 0);
cv = convert_open(type, format, root, cwd, dbpath, stdout, db);
/*
* search through tag file.
*/
if (nofilter & SORT_FILTER)
flags |= GTOP_NOSORT;
if (Gflag)
flags |= GTOP_BASICREGEX;
if (format == FORMAT_PATH)
flags |= GTOP_PATH;
if (iflag)
flags |= GTOP_IGNORECASE;
for (gtp = gtags_first(gtop, pattern, flags); gtp; gtp = gtags_next(gtop)) {
if (Sflag && !locatestring(gtp->path, localprefix, MATCH_AT_FIRST))
continue;
count += output_with_formatting(cv, gtp, gtop->format);
}
convert_close(cv);
if (debug)
gtags_show_statistics(gtop);
gtags_close(gtop);
end_output();
return count;
}
int main(int argc, char *argv[])
{
if (argc < 3)
{
printf("Usage: #simple_demo ip port\n");
return -1;
}
struct cap_handle *caphandle = NULL;
struct cvt_handle *cvthandle = NULL;
struct enc_handle *enchandle = NULL;
struct pac_handle *pachandle = NULL;
struct net_handle *nethandle = NULL;
struct cap_param capp;
struct cvt_param cvtp;
struct enc_param encp;
struct pac_param pacp;
struct net_param netp;
// set paraments
U32 vfmt = V4L2_PIX_FMT_YUYV;
U32 ofmt = V4L2_PIX_FMT_YUV420;
capp.dev_name = "/dev/video0";
capp.width = WIDTH;
capp.height = HEIGHT;
capp.pixfmt = vfmt;
capp.rate = FRAMERATE;
cvtp.inwidth = WIDTH;
cvtp.inheight = HEIGHT;
cvtp.inpixfmt = vfmt;
cvtp.outwidth = WIDTH;
cvtp.outheight = HEIGHT;
cvtp.outpixfmt = ofmt;
encp.src_picwidth = WIDTH;
encp.src_picheight = HEIGHT;
encp.enc_picwidth = WIDTH;
encp.enc_picheight = HEIGHT;
encp.chroma_interleave = 0;
encp.fps = FRAMERATE;
encp.gop = 30;
encp.bitrate = 800;
pacp.max_pkt_len = 1400;
pacp.ssrc = 10;
netp.type = UDP;
netp.serip = argv[1];
netp.serport = atoi(argv[2]);
caphandle = capture_open(capp);
if (!caphandle)
{
printf("--- Open capture failed\n");
return -1;
}
cvthandle = convert_open(cvtp);
if (!cvthandle)
{
printf("--- Open convert failed\n");
return -1;
}
enchandle = encode_open(encp);
if (!enchandle)
{
printf("--- Open encode failed\n");
return -1;
}
pachandle = pack_open(pacp);
if (!pachandle)
{
printf("--- Open pack failed\n");
return -1;
}
nethandle = net_open(netp);
if (!nethandle)
{
printf("--- Open network failed\n");
return -1;
}
// start stream loop
int ret;
void *cap_buf, *cvt_buf, *hd_buf, *enc_buf, *pac_buf;
int cap_len, cvt_len, hd_len, enc_len, pac_len;
enum pic_t ptype;
unsigned long framecount = 0;
capture_start(caphandle); // !!! need to start capture stream!
while (1)
{
ret = capture_get_data(caphandle, &cap_buf, &cap_len);
if (ret != 0)
{
if (ret < 0) // error
{
printf("--- capture_get_data failed\n");
break;
}
else // again
{
usleep(10000);
continue;
}
}
if (cap_len <= 0)
{
printf("!!! No capture data\n");
continue;
}
// else
ret = convert_do(cvthandle, cap_buf, cap_len, &cvt_buf, &cvt_len);
if (ret < 0)
{
printf("--- convert_do failed\n");
break;
}
if (cvt_len <= 0)
{
printf("!!! No convert data\n");
continue;
}
// else
// fetch h264 headers first!
while ((ret = encode_get_headers(enchandle, &hd_buf, &hd_len, &ptype))
== 1)
{
//fwrite(hd_buf, 1, hd_len, dumpfile);
pack_put(pachandle, hd_buf, hd_len);
while (pack_get(pachandle, &pac_buf, &pac_len) == 1)
{
ret = net_send(nethandle, pac_buf, pac_len);
if (ret != pac_len)
{
printf("send pack data failed, size: %d, err: %s\n", pac_len,
strerror(errno));
}
}
}
ret = encode_do(enchandle, cvt_buf, cvt_len, &enc_buf, &enc_len,
&ptype);
if (ret < 0)
{
printf("--- encode_do failed\n");
break;
}
if (enc_len <= 0)
{
printf("!!! No encode data\n");
continue;
}
// else
//fwrite(enc_buf, 1, enc_len, dumpfile);
// RTP pack and send
pack_put(pachandle, enc_buf, enc_len);
while (pack_get(pachandle, &pac_buf, &pac_len) == 1)
{
ret = net_send(nethandle, pac_buf, pac_len);
if (ret != pac_len)
{
printf("send pack failed, size: %d, err: %s\n", pac_len,
strerror(errno));
}
}
framecount++;
}
capture_stop(caphandle);
net_close(nethandle);
pack_close(pachandle);
encode_close(enchandle);
convert_close(cvthandle);
capture_close(caphandle);
return 0;
}
/*
* grep: grep pattern
*
* i) pattern POSIX regular expression
*/
void
grep(const char *pattern, char *const *argv, const char *dbpath)
{
FILE *fp;
CONVERT *cv;
GFIND *gp = NULL;
STRBUF *ib = strbuf_open(MAXBUFLEN);
const char *path;
char encoded_pattern[IDENTLEN];
const char *buffer;
int linenum, count;
int flags = 0;
int target = GPATH_SOURCE;
regex_t preg;
int user_specified = 1;
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (!Gflag)
flags |= REG_EXTENDED;
if (iflag)
flags |= REG_ICASE;
if (regcomp(&preg, pattern, flags) != 0)
die("invalid regular expression.");
cv = convert_open(type, format, root, cwd, dbpath, stdout);
count = 0;
if (*argv && file_list)
args_open_both(argv, file_list);
else if (*argv)
args_open(argv);
else if (file_list)
args_open_filelist(file_list);
else {
args_open_gfind(gp = gfind_open(dbpath, localprefix, target));
user_specified = 0;
}
while ((path = args_read()) != NULL) {
if (user_specified) {
static char buf[MAXPATHLEN];
if (normalize(path, get_root_with_slash(), cwd, buf, sizeof(buf)) == NULL)
if (!qflag)
fprintf(stderr, "'%s' is out of source tree.\n", path);
if (!test("f", buf))
die("'%s' not found. Please remake tag files by invoking gtags(1).", path);
path = buf;
}
if (!(fp = fopen(path, "r")))
die("cannot open file '%s'.", path);
linenum = 0;
while ((buffer = strbuf_fgets(ib, fp, STRBUF_NOCRLF)) != NULL) {
int result = regexec(&preg, buffer, 0, 0, 0);
linenum++;
if ((!Vflag && result == 0) || (Vflag && result != 0)) {
count++;
if (format == FORMAT_PATH) {
convert_put_path(cv, path);
break;
} else {
convert_put_using(cv, encoded_pattern, path, linenum, buffer,
(user_specified) ? NULL : gp->dbop->lastdat);
}
}
}
fclose(fp);
}
args_close();
convert_close(cv);
strbuf_close(ib);
regfree(&preg);
if (vflag) {
print_count(count);
fprintf(stderr, " (no index used).\n");
}
}
/*
* idutils: lid(idutils) pattern
*
* i) pattern POSIX regular expression
* i) dbpath GTAGS directory
*/
void
idutils(const char *pattern, const char *dbpath)
{
FILE *ip;
CONVERT *cv;
STRBUF *ib = strbuf_open(0);
char encoded_pattern[IDENTLEN];
char path[MAXPATHLEN];
const char *lid;
int linenum, count;
char *p, *q, *grep;
lid = usable("lid");
if (!lid)
die("lid(idutils) not found.");
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
/*
* make lid command line.
* Invoke lid with the --result=grep option to generate grep format.
*/
strbuf_puts(ib, lid);
strbuf_sprintf(ib, " --file='%s/ID'", dbpath);
strbuf_puts(ib, " --separator=newline");
if (format == FORMAT_PATH)
strbuf_puts(ib, " --result=filenames --key=none");
else
strbuf_puts(ib, " --result=grep");
if (iflag)
strbuf_puts(ib, " --ignore-case");
strbuf_putc(ib, ' ');
strbuf_puts(ib, quote_string(pattern));
if (debug)
fprintf(stderr, "idutils: %s\n", strbuf_value(ib));
if (!(ip = popen(strbuf_value(ib), "r")))
die("cannot execute '%s'.", strbuf_value(ib));
cv = convert_open(type, format, root, cwd, dbpath, stdout);
count = 0;
strcpy(path, "./");
while ((grep = strbuf_fgets(ib, ip, STRBUF_NOCRLF)) != NULL) {
q = path + 2;
/* extract path name */
if (*grep == '/')
die("The path in the output of lid is assumed absolute. '%s'", grep);
p = grep;
while (*p && *p != ':')
*q++ = *p++;
*q = '\0';
if ((xflag || tflag) && !*p)
die("invalid lid(idutils) output format(1). '%s'", grep);
p++;
if (lflag) {
if (!locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
}
count++;
switch (format) {
case FORMAT_PATH:
convert_put_path(cv, path);
break;
default:
/* extract line number */
while (*p && isspace(*p))
p++;
linenum = 0;
for (linenum = 0; *p && isdigit(*p); linenum = linenum * 10 + (*p++ - '0'))
;
if (*p != ':')
die("invalid lid(idutils) output format(2). '%s'", grep);
if (linenum <= 0)
die("invalid lid(idutils) output format(3). '%s'", grep);
p++;
/*
* print out.
*/
convert_put_using(cv, encoded_pattern, path, linenum, p, NULL);
break;
}
}
if (pclose(ip) < 0)
die("terminated abnormally.");
convert_close(cv);
strbuf_close(ib);
if (vflag) {
print_count(count);
fprintf(stderr, " (using idutils index in '%s').\n", dbpath);
}
}
int
search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
{
CONVERT *cv;
int count = 0;
GTOP *gtop;
GTP *gtp;
int flags = 0;
STRBUF *sb = NULL, *ib = NULL;
char curpath[MAXPATHLEN], curtag[IDENTLEN];
FILE *fp = NULL;
const char *src = "";
int lineno, last_lineno;
lineno = last_lineno = 0;
curpath[0] = curtag[0] = '\0';
/*
* open tag file.
*/
gtop = gtags_open(dbpath, root, db, GTAGS_READ, 0);
cv = convert_open(type, format, root, cwd, dbpath, stdout);
/*
* search through tag file.
*/
if (nofilter & SORT_FILTER)
flags |= GTOP_NOSORT;
if (iflag) {
if (!isregex(pattern)) {
sb = strbuf_open(0);
strbuf_putc(sb, '^');
strbuf_puts(sb, pattern);
strbuf_putc(sb, '$');
pattern = strbuf_value(sb);
}
flags |= GTOP_IGNORECASE;
}
if (Gflag)
flags |= GTOP_BASICREGEX;
if (format == FORMAT_PATH)
flags |= GTOP_PATH;
if (gtop->format & GTAGS_COMPACT)
ib = strbuf_open(0);
for (gtp = gtags_first(gtop, pattern, flags); gtp; gtp = gtags_next(gtop)) {
if (lflag && !locatestring(gtp->path, localprefix, MATCH_AT_FIRST))
continue;
if (format == FORMAT_PATH) {
convert_put_path(cv, gtp->path);
count++;
} else if (gtop->format & GTAGS_COMPACT) {
/*
* Compact format:
* a b
* tagline = <file id> <tag name> <line no>,...
*/
char *p = (char *)gtp->tagline;
const char *fid, *tagname;
int n = 0;
fid = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* a */
tagname = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* b */
/*
* Reopen or rewind source file.
*/
if (!nosource) {
if (strcmp(gtp->path, curpath) != 0) {
if (curpath[0] != '\0' && fp != NULL)
fclose(fp);
strlimcpy(curtag, tagname, sizeof(curtag));
strlimcpy(curpath, gtp->path, sizeof(curpath));
/*
* Use absolute path name to support GTAGSROOT
* environment variable.
*/
fp = fopen(makepath(root, curpath, NULL), "r");
if (fp == NULL)
warning("source file '%s' is not available.", curpath);
last_lineno = lineno = 0;
} else if (strcmp(gtp->tag, curtag) != 0) {
strlimcpy(curtag, gtp->tag, sizeof(curtag));
if (atoi(p) < last_lineno && fp != NULL) {
rewind(fp);
lineno = 0;
}
last_lineno = 0;
}
}
/*
* Unfold compact format.
*/
if (!isdigit(*p))
die("illegal compact format.");
if (gtop->format & GTAGS_COMPLINE) {
/*
*
* If GTAGS_COMPLINE flag is set, each line number is expressed as
* the difference from the previous line number except for the head.
* Please see flush_pool() in libutil/gtagsop.c for the details.
*/
int last = 0, cont = 0;
while (*p || cont > 0) {
if (cont > 0) {
n = last + 1;
if (n > cont) {
cont = 0;
continue;
}
} else if (isdigit(*p)) {
GET_NEXT_NUMBER(p);
} else if (*p == '-') {
GET_NEXT_NUMBER(p);
cont = n + last;
n = last + 1;
} else if (*p == ',') {
GET_NEXT_NUMBER(p);
n += last;
}
if (last_lineno != n && fp) {
while (lineno < n) {
if (!(src = strbuf_fgets(ib, fp, STRBUF_NOCRLF))) {
src = "";
fclose(fp);
fp = NULL;
break;
}
lineno++;
}
}
if (gtop->format & GTAGS_COMPNAME)
tagname = (char *)uncompress(tagname, gtp->tag);
convert_put_using(cv, tagname, gtp->path, n, src, fid);
count++;
last_lineno = last = n;
}
} else {
/*
* In fact, when GTAGS_COMPACT is set, GTAGS_COMPLINE is allways set.
* Therefore, the following code are not actually used.
* However, it is left for some test.
*/
while (*p) {
for (n = 0; isdigit(*p); p++)
n = n * 10 + *p - '0';
if (*p == ',')
p++;
if (last_lineno == n)
continue;
if (last_lineno != n && fp) {
while (lineno < n) {
if (!(src = strbuf_fgets(ib, fp, STRBUF_NOCRLF))) {
src = "";
fclose(fp);
fp = NULL;
break;
}
lineno++;
}
}
if (gtop->format & GTAGS_COMPNAME)
tagname = (char *)uncompress(tagname, gtp->tag);
convert_put_using(cv, tagname, gtp->path, n, src, fid);
count++;
last_lineno = n;
}
}
} else {
/*
* Standard format:
* a b c
* tagline = <file id> <tag name> <line no> <line image>
*/
char *p = (char *)gtp->tagline;
char namebuf[IDENTLEN];
const char *fid, *tagname, *image;
fid = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* a */
tagname = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* b */
if (gtop->format & GTAGS_COMPNAME) {
strlimcpy(namebuf, (char *)uncompress(tagname, gtp->tag), sizeof(namebuf));
tagname = namebuf;
}
if (nosource) {
image = " ";
} else {
while (*p != ' ')
p++;
image = p + 1; /* c + 1 */
if (gtop->format & GTAGS_COMPRESS)
image = (char *)uncompress(image, gtp->tag);
}
convert_put_using(cv, tagname, gtp->path, gtp->lineno, image, fid);
count++;
}
}
convert_close(cv);
if (sb)
strbuf_close(sb);
if (ib)
strbuf_close(ib);
if (fp)
fclose(fp);
gtags_close(gtop);
return count;
}
void
parsefile(char *const *argv, const char *cwd, const char *root, const char *dbpath, int db)
{
int count = 0;
int file_count = 0;
STRBUF *sb = strbuf_open(0);
char *langmap;
const char *plugin_parser, *av;
char path[MAXPATHLEN];
struct parsefile_data data;
if (db == GRTAGS + GSYMS)
data.target = TARGET_REF|TARGET_SYM;
else
data.target = 1 << db;
data.extractmethod = getconfb("extractmethod");
if (getconfs("langmap", sb))
langmap = check_strdup(strbuf_value(sb));
else
langmap = NULL;
strbuf_reset(sb);
if (getconfs("gtags_parser", sb))
plugin_parser = strbuf_value(sb);
else
plugin_parser = NULL;
data.cv = convert_open(type, format, root, cwd, dbpath, stdout);
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
if (data.target == TARGET_REF || data.target == TARGET_SYM) {
data.dbop = dbop_open(makepath(dbpath, dbname(GTAGS), NULL), 0, 0, 0);
if (data.dbop == NULL)
die("%s not found.", dbname(GTAGS));
} else {
data.dbop = NULL;
}
data.fid = NULL;
parser_init(langmap, plugin_parser);
if (langmap != NULL)
free(langmap);
if (*argv && file_list)
args_open_both(argv, file_list);
else if (*argv)
args_open(argv);
else if (file_list)
args_open_filelist(file_list);
else
args_open_nop();
while ((av = args_read()) != NULL) {
/*
* convert the path into relative to the root directory of source tree.
*/
if (normalize(av, get_root_with_slash(), cwd, path, sizeof(path)) == NULL)
if (!qflag)
fprintf(stderr, "'%s' is out of source tree.\n", path + 2);
/*
* Memorize the file id of the path. This is used in put_syms().
*/
{
static char s_fid[MAXFIDLEN];
const char *p = gpath_path2fid(path, NULL);
if (!p) {
if (!qflag)
fprintf(stderr, "'%s' not found in GPATH.\n", path + 2);
continue;
}
strlimcpy(s_fid, p, sizeof(s_fid));
data.fid = s_fid;
}
if (!test("f", makepath(root, path, NULL))) {
if (test("d", NULL)) {
if (!qflag)
fprintf(stderr, "'%s' is a directory.\n", av);
} else {
if (!qflag)
fprintf(stderr, "'%s' not found.\n", av);
}
continue;
}
if (lflag && !locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
data.count = 0;
parse_file(path, 0, put_syms, &data);
count += data.count;
file_count++;
}
args_close();
parser_exit();
/*
* Settlement
*/
if (data.dbop != NULL)
dbop_close(data.dbop);
gpath_close();
convert_close(data.cv);
strbuf_close(sb);
if (vflag) {
print_count(count);
fprintf(stderr, " (no index used).\n");
}
}
/*
* pathlist: print candidate path list.
*
* i) dbpath
*/
void
pathlist(const char *pattern, const char *dbpath)
{
GFIND *gp;
CONVERT *cv;
const char *path, *p;
regex_t preg;
int count;
int target = GPATH_SOURCE;
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (pattern) {
int flags = 0;
char edit[IDENTLEN];
if (!Gflag)
flags |= REG_EXTENDED;
if (iflag || getconfb("icase_path"))
flags |= REG_ICASE;
#ifdef _WIN32
flags |= REG_ICASE;
#endif /* _WIN32 */
/*
* We assume '^aaa' as '^/aaa'.
*/
if (*pattern == '^' && *(pattern + 1) != '/') {
snprintf(edit, sizeof(edit), "^/%s", pattern + 1);
pattern = edit;
}
if (regcomp(&preg, pattern, flags) != 0)
die("invalid regular expression.");
}
if (!localprefix)
localprefix = "./";
cv = convert_open(type, format, root, cwd, dbpath, stdout);
count = 0;
gp = gfind_open(dbpath, localprefix, target);
while ((path = gfind_read(gp)) != NULL) {
/*
* skip localprefix because end-user doesn't see it.
*/
p = path + strlen(localprefix) - 1;
if (pattern) {
int result = regexec(&preg, p, 0, 0, 0);
if ((!Vflag && result != 0) || (Vflag && result == 0))
continue;
} else if (Vflag)
continue;
if (format == FORMAT_PATH)
convert_put_path(cv, path);
else
convert_put_using(cv, "path", path, 1, " ", gp->dbop->lastdat);
count++;
}
gfind_close(gp);
convert_close(cv);
if (pattern)
regfree(&preg);
if (vflag) {
switch (count) {
case 0:
fprintf(stderr, "file not found");
break;
case 1:
fprintf(stderr, "1 file located");
break;
default:
fprintf(stderr, "%d files located", count);
break;
}
fprintf(stderr, " (using '%s').\n", makepath(dbpath, dbname(GPATH), NULL));
}
}
int main(int argc, char *argv[])
{
char **url = NULL;
int n_url = 0, cur_url = 0;
int check_interval = 15 * 60;
mrss_t **data_prev = NULL;
mrss_t **data_cur = NULL;
int data_size;
char *proxy = NULL, *proxy_auth = NULL;
int sw;
int verbose = 0;
int notify_friendly = 0;
char show_timestamp = 0, show_link = 0, show_description = 0, show_pubdate = 0, show_author = 0, show_comments = 0;
char strip_html = 0, no_error_exit = 0;
char one_shot = 0;
char no_heading = 0;
int bytes_limit = 0;
time_t last_changed = (time_t)0;
char continue_on_error = 0/*, dummy*/;
int show_n = -1;
/*long int max_age = -1;*/
char *heading = NULL;
mrss_options_t mot;
convert_context_t conv_context;
convert_context_t* cc = &conv_context;
char *conv_title = 0;
char *rss_title = 0;
char *conv_rss_title = 0;
char *conv_author = 0;
char *conv_description = 0;
char *conv_comments = 0;
tzset();
setlocale(LC_ALL, "");
memset(&mot, 0x00, sizeof(mot));
while((sw = getopt(argc, argv, "Z:1b:PHztldpacmu:Ni:n:x:y:vVh")) != -1)
{
switch(sw)
{
case 'Z':
heading = optarg;
break;
case 'N':
no_heading = 1;
break;
case 'm':
notify_friendly = 1;
break;
case '1':
one_shot = 1;
break;
case 'b':
bytes_limit = atoi(optarg);
if (bytes_limit <= 0)
{
fprintf(stderr, "-b requires a number > 0\n");
return 1;
}
break;
case 'P':
no_error_exit = 1;
break;
case 'H':
strip_html = 1;
break;
case 'n':
show_n = atoi(optarg);
if (show_n < 0)
{
fprintf(stderr, "-n requires an positive value\n");
return 1;
}
else if (show_n > 50)
fprintf(stderr, "Initially showing more then 50 items, must be one hell of an rss feed!\n");
break;
#if 0
case 'o':
dummy = optarg[strlen(optarg) - 1];
max_age = atoi(optarg);
if (max_age < 0)
{
printf("-o requires an positive value\n");
return 1;
}
if (dummy == 's')
max_age *= 1;
else if (dummy == 'M')
max_age *= 60;
else if (dummy == 'h')
max_age *= 3600;
else if (dummy == 'd')
max_age *= 86400;
else if (dummy == 'm')
max_age *= 86400 * 31;
else if (dummy == 'y')
max_age *= 86400 * 365.25;
else if (isalpha(dummy))
{
printf("'%c' is a not recognized multiplier\n", dummy);
return 1;
}
break;
#endif
case 'z':
continue_on_error = 1;
break;
case 't':
show_timestamp = 1;
break;
case 'l':
show_link = 1;
break;
case 'd':
show_description = 1;
break;
case 'p':
show_pubdate = 1;
break;
case 'a':
show_author = 1;
break;
case 'c':
show_comments = 1;
break;
case 'u':
url = (char **)realloc(url, sizeof(char *) * (n_url + 1));
if (!url)
{
fprintf(stderr, "Cannot allocate memory\n");
return 2;
}
url[n_url++] = optarg;
break;
case 'i':
check_interval = atoi(optarg);
break;
case 'x':
proxy = optarg;
break;
case 'y':
proxy_auth = optarg;
break;
case 'v':
verbose++;
break;
case 'V':
version();
return 1;
case 'h':
default:
usage();
return 1;
}
}
mot.timeout = check_interval;
mot.proxy = proxy;
mot.proxy_authentication = proxy_auth;
mot.user_agent = "rsstail " VERSION ", (C) 2006-2007 by [email protected]";
if (n_url == 0)
{
fprintf(stderr, "Please give the URL of the RSS feed to check with the '-u' parameter.\n");
return 1;
}
data_size = sizeof(mrss_t *) * n_url;
data_prev = (mrss_t **)malloc(data_size);
data_cur = (mrss_t **)malloc(data_size);
if (!data_prev || !data_cur)
{
fprintf(stderr, "Cannot allocate memory\n");
return 2;
}
memset(data_prev, 0x00, data_size);
memset(data_cur , 0x00, data_size);
if (verbose)
{
int loop;
fprintf(stderr, "Monitoring RSS feeds:\n");
for(loop=0; loop<n_url; loop++)
fprintf(stderr, "\t%s\n", url[loop]);
fprintf(stderr, "Check interval: %d\n", check_interval);
}
for(;;)
{
mrss_error_t err_read;
mrss_item_t *item_cur = NULL;
time_t cur_last_changed;
int n_shown = 0;
if (verbose)
fprintf(stderr, "Retrieving RSS feed '%s'...\n", url[cur_url]);
if ((err_read = mrss_get_last_modified(url[cur_url], &cur_last_changed)) != MRSS_OK)
{
if (err_read == MRSS_ERR_POSIX)
{
if (errno == EINPROGRESS)
{
fprintf(stderr, "Time-out while connecting to RSS feed, continuing\n");
goto goto_next_url;
}
}
fprintf(stderr, "Error reading RSS feed: %s\n", mrss_strerror(err_read));
if (no_error_exit)
goto goto_next_url;
else
return 2;
}
if (cur_last_changed == last_changed && cur_last_changed != 0)
{
if (verbose)
fprintf(stderr, "Feed did not change since last check.\n");
goto goto_next_url;
}
last_changed = cur_last_changed;
if ((err_read = mrss_parse_url_with_options(url[cur_url], &data_cur[cur_url], &mot)) != MRSS_OK)
{
if (err_read == MRSS_ERR_POSIX)
{
if (errno == EINPROGRESS)
{
fprintf(stderr, "Time-out while connecting to RSS feed, continuing\n");
goto goto_next_url;
}
}
else if (err_read == MRSS_ERR_PARSER && continue_on_error)
{
fprintf(stderr, "Error reading RSS feed: %s\n", mrss_strerror(err_read));
goto goto_next_url;
}
fprintf(stderr, "Error reading RSS feed: %s\n", mrss_strerror(err_read));
if (no_error_exit)
goto goto_next_url;
else
return 2;
}
item_cur = data_cur[cur_url] -> item;
rss_title = data_cur[cur_url] -> title;
if( !convert_init(cc, data_cur[cur_url]->encoding, convert_system_enc()) )
{
fprintf(stderr, "\nERROR: iconv initialization error.\n" );
}
while(item_cur)
{
if ((data_prev[cur_url] && is_new_record(data_prev[cur_url] -> item, item_cur) != -1) ||
(!data_prev[cur_url]))
{
#if 0
if (/* pubdate */ < max_age && max_age != -1)
continue;
#endif
if ((!data_prev[cur_url]) && n_shown >= show_n && show_n != -1)
{
item_cur = item_cur -> next;
continue;
}
n_shown++;
if ((show_link + show_description + show_pubdate + show_author + show_comments ) > 1 && !notify_friendly )
printf("\n");
if (show_timestamp)
{
time_t now = time(NULL);
struct tm *now_tm = localtime(&now);
printf("%04d/%02d/%02d %02d:%02d:%02d ",
now_tm -> tm_year + 1900,
now_tm -> tm_mon + 1,
now_tm -> tm_mday,
now_tm -> tm_hour,
now_tm -> tm_min,
now_tm -> tm_sec);
}
if (show_pubdate && item_cur -> pubDate != NULL)
{
if ( notify_friendly )
{
char* new_date_str = convert_pub_date(item_cur->pubDate);
printf("%s%s ", no_heading?" ":"Pub.date: ", new_date_str);
free(new_date_str);
}
else
{
printf("%s%s\n", no_heading?" ":"Pub.date: ", item_cur -> pubDate);
}
}
if (heading)
{
printf(" %s", heading);
}
if ( notify_friendly )
{
if ( rss_title )
{
conv_rss_title = convert(cc, rss_title);
printf("%s*%s* ", no_heading?" ":"RSS Title: ", conv_rss_title);
free(conv_rss_title);
}
}
if (item_cur -> title != NULL)
{
conv_title = convert(cc, item_cur->title);
printf("%s%s%s", no_heading?" ":"Title: ", conv_title, (notify_friendly?" ":"\n"));
free(conv_title);
}
if (show_link && item_cur -> link != NULL)
{
if ( notify_friendly )
{
printf("%s<a href=\"%s\">Link</a>\n", no_heading?" ":"Link: ", item_cur -> link );
}
else
{
printf("%s%s\n", no_heading?" ":"Link: ", item_cur -> link );
}
}
else
{
if ( notify_friendly )
{
printf("\n"); //crlf without Link html tag
}
}
if (show_description && item_cur -> description != NULL)
{
if (strip_html)
{
char *stripped = remove_html_tags(item_cur -> description);
if (bytes_limit != 0 && bytes_limit < strlen(stripped))
stripped[bytes_limit] = 0x00;
conv_description = convert(cc, stripped);
printf("%s%s\n", no_heading?" ":"Description: ", conv_description);
free(conv_description);
free(stripped);
}
else
{
if (bytes_limit != 0 && bytes_limit < strlen(item_cur -> description))
(item_cur -> description)[bytes_limit] = 0x00;
conv_description = convert(cc, item_cur->description);
printf("%s%s\n", no_heading?" ":"Description: ", conv_description);
free(conv_description);
}
}
if (show_author && item_cur -> author != NULL)
{
conv_author = convert(cc, item_cur->author);
printf("%s%s\n", no_heading?" ":"Author: ", conv_author);
free(conv_author);
}
if (show_comments && item_cur -> comments != NULL)
{
if (bytes_limit != 0 && bytes_limit < strlen(item_cur -> comments))
(item_cur -> comments)[bytes_limit] = 0x00;
conv_comments = convert(cc, item_cur->comments);
printf("%s%s\n", no_heading?" ":"Comments: ", conv_comments);
free(conv_comments);
}
}
item_cur = item_cur -> next;
}
convert_close(cc);
if (data_prev[cur_url])
{
mrss_error_t err_free = mrss_free(data_prev[cur_url]);
if (err_free != MRSS_OK)
{
fprintf(stderr, "Error freeing up memory: %s\n", mrss_strerror(err_read));
if (no_error_exit)
goto goto_next_url;
else
return 2;
}
}
data_prev[cur_url] = data_cur[cur_url];
data_cur[cur_url] = NULL;
goto_next_url:
cur_url++;
if (cur_url == n_url)
cur_url = 0;
fflush(stdout);
if (one_shot)
break;
if (verbose > 2)
fprintf(stderr, "Sleeping...\n");
sleep(check_interval / n_url);
}
return 0;
}
/**
* \brief Input plugin "destructor".
*
* \param[in,out] config plugin_info structure
* \return 0 on success and config is changed to NULL, nonzero else.
*/
int input_close(void **config)
{
int ret, error = 0, sock=0;
struct plugin_conf *conf = (struct plugin_conf*) *config;
struct input_info_list *info_list;
/* kill the listening thread */
if(pthread_cancel(listen_thread) != 0) {
MSG_WARNING(msg_module, "Cannot cancel listening thread");
} else {
pthread_join(listen_thread, NULL);
}
#ifdef TLS_SUPPORT
if (conf->tls) {
/* close TLS connection, if any */
for (sock = 0; sock < conf->ssl_list_size; sock++) {
if (conf->ssl_list[sock] == NULL) {
continue;
}
ret = SSL_get_fd(conf->ssl_list[sock]);
if (ret >= 0) {
/* send close notify */
ret = SSL_shutdown(conf->ssl_list[sock]);
if (ret == -1) {
MSG_ERROR(msg_module, "Fatal error occured during TLS close notify");
}
}
SSL_free(conf->ssl_list[sock]);
}
/* we are done here */
SSL_CTX_free(conf->ctx);
}
#endif
/* close listening socket */
if ((ret = close(conf->socket)) == -1) {
error++;
MSG_ERROR(msg_module, "Cannot close listening socket: %s", strerror(errno));
}
/* close open sockets */
for (sock = 0; sock <= conf->fd_max; sock++) {
if (FD_ISSET(sock, &conf->master)) {
if ((ret = close(sock)) == -1) {
error++;
MSG_ERROR(msg_module, "Cannot close socket: %s", strerror(errno));
}
}
}
destroy_sock_addresses(conf);
/* free input_info list */
while (conf->info_list) {
info_list = conf->info_list->next;
#ifdef TLS_SUPPORT
X509_free(conf->info_list->exporter_cert);
#endif
free(conf->info_list);
conf->info_list = info_list;
}
/* free configuration strings */
if (conf->info.template_life_time != NULL) {
free(conf->info.template_life_time);
}
if (conf->info.template_life_packet != NULL) {
free(conf->info.template_life_packet);
}
if (conf->info.options_template_life_time != NULL) {
free(conf->info.options_template_life_time);
}
if (conf->info.options_template_life_packet != NULL) {
free(conf->info.options_template_life_packet);
}
#ifdef TLS_SUPPORT
/* free strings that are not default (thus static) */
if (conf->ca_cert_file != NULL) {
free(conf->ca_cert_file);
}
if (conf->server_cert_file != NULL) {
free(conf->server_cert_file);
}
if (conf->server_pkey_file != NULL) {
free(conf->server_pkey_file);
}
#endif
/* free allocated structures */
FD_ZERO(&conf->master);
free(*config);
convert_close();
*config = NULL;
MSG_INFO(msg_module, "All allocated resources have been freed");
return error;
}
int
main(int argc, char **argv)
{
char dbpath[MAXPATHLEN];
char cwd[MAXPATHLEN];
STRBUF *sb = strbuf_open(0);
int optchar;
int option_index = 0;
STATISTICS_TIME *tim;
while ((optchar = getopt_long(argc, argv, "cd:f:iuIn:oOqvwse", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
/* already flags set */
break;
case OPT_CONFIG:
show_config = 1;
if (optarg)
config_name = optarg;
break;
case OPT_GTAGSCONF:
gtagsconf = optarg;
break;
case OPT_GTAGSLABEL:
gtagslabel = optarg;
break;
case OPT_PATH:
do_path = 1;
if (!strcmp("absolute", optarg))
convert_type = PATH_ABSOLUTE;
else if (!strcmp("relative", optarg))
convert_type = PATH_RELATIVE;
else if (!strcmp("through", optarg))
convert_type = PATH_THROUGH;
else
die("Unknown path type.");
break;
case OPT_SINGLE_UPDATE:
iflag++;
single_update = optarg;
break;
case OPT_ENCODE_PATH:
if (strlen(optarg) > 255)
die("too many encode chars.");
if (strchr(optarg, '/') || strchr(optarg, '.'))
die("cannot encode '/' and '.' in the path.");
set_encode_chars((unsigned char *)optarg);
break;
case 'c':
cflag++;
break;
case 'd':
dump_target = optarg;
break;
case 'f':
file_list = optarg;
break;
case 'i':
iflag++;
break;
case 'u':
uflag++;
iflag++;
break;
case 'I':
Iflag++;
break;
case 'o':
/*
* Though the -o(--omit-gsyms) was removed, this code
* is left for compatibility.
*/
break;
case 'O':
Oflag++;
break;
case 'q':
qflag++;
setquiet();
break;
case 'w':
wflag++;
break;
case 'v':
vflag++;
setverbose();
break;
default:
usage();
break;
}
}
if (gtagsconf) {
char path[MAXPATHLEN];
if (realpath(gtagsconf, path) == NULL)
die("%s not found.", gtagsconf);
set_env("GTAGSCONF", path);
}
if (gtagslabel) {
set_env("GTAGSLABEL", gtagslabel);
}
if (qflag)
vflag = 0;
if (show_version)
version(NULL, vflag);
if (show_help)
help();
argc -= optind;
argv += optind;
/* If dbpath is specified, -O(--objdir) option is ignored. */
if (argc > 0)
Oflag = 0;
if (show_config) {
if (config_name)
printconf(config_name);
else
fprintf(stdout, "%s\n", getconfline());
exit(0);
} else if (do_path) {
/*
* This is the main body of path filter.
* This code extract path name from tag line and
* replace it with the relative or the absolute path name.
*
* By default, if we are in src/ directory, the output
* should be converted like follws:
*
* main 10 ./src/main.c main(argc, argv)\n
* main 22 ./libc/func.c main(argc, argv)\n
* v
* main 10 main.c main(argc, argv)\n
* main 22 ../libc/func.c main(argc, argv)\n
*
* Similarly, the --path=absolute option specified, then
* v
* main 10 /prj/xxx/src/main.c main(argc, argv)\n
* main 22 /prj/xxx/libc/func.c main(argc, argv)\n
*/
STRBUF *ib = strbuf_open(MAXBUFLEN);
CONVERT *cv;
char *ctags_x;
if (argc < 3)
die("gtags --path: 3 arguments needed.");
cv = convert_open(convert_type, FORMAT_CTAGS_X, argv[0], argv[1], argv[2], stdout);
while ((ctags_x = strbuf_fgets(ib, stdin, STRBUF_NOCRLF)) != NULL)
convert_put(cv, ctags_x);
convert_close(cv);
strbuf_close(ib);
exit(0);
} else if (dump_target) {
/*
* Dump a tag file.
*/
DBOP *dbop = NULL;
const char *dat = 0;
int is_gpath = 0;
char* target_file = NULL;
if (!test("f", dump_target)) {
target_file = strchr(dump_target, ':');
if (target_file == NULL)
die("file '%s' not found", dump_target);
*target_file++ = 0; //move to the next char, which starts the target file.
if (!test("f", dump_target)) {
die("file '%s' not found.", dump_target);
}
}
if ((dbop = dbop_open(dump_target, 0, 0, DBOP_RAW)) == NULL)
die("file '%s' is not a tag file.", dump_target);
/*
* The file which has a NEXTKEY record is GPATH.
*/
if (dbop_get(dbop, NEXTKEY))
is_gpath = 1;
if (target_file && !is_gpath) {
die("dump target_file can only be used with GPATH");
}
if (target_file) {
dat = dbop_get(dbop, target_file);
if (dat == NULL) {
die("target_file %s not found in GPATH", target_file);
}
time_t t = gpath_mtime(dbop, target_file);
printf("%d\n", t);
} else {
for (dat = dbop_first(dbop, NULL, NULL, 0); dat != NULL; dat = dbop_next(dbop)) {
const char *flag = is_gpath ? dbop_getflag(dbop) : "";
if (*flag)
if (is_gpath) {
time_t t = gpath_mtime(dbop, dbop->lastkey);
printf("%s\t%s\t%s\t%s\n", dbop->lastkey, dat, flag, ctime(&t));
} else
printf("%s\t%s\t%s\n", dbop->lastkey, dat, flag);
else
printf("%s\t%s\n", dbop->lastkey, dat);
}
}
dbop_close(dbop);
exit(0);
} else if (Iflag) {
if (!usable("mkid"))
die("mkid not found.");
}
/*
* If 'gtags.files' exists, use it as a file list.
* If the file_list other than "-" is given, it must be readable file.
*/
if (file_list == NULL && test("f", GTAGSFILES))
file_list = GTAGSFILES;
if (file_list && strcmp(file_list, "-")) {
if (test("d", file_list))
die("'%s' is a directory.", file_list);
else if (!test("f", file_list))
die("'%s' not found.", file_list);
else if (!test("r", file_list))
die("'%s' is not readable.", file_list);
}
/*
* Regularize the path name for single updating (--single-update).
*/
if (single_update) {
static char regular_path_name[MAXPATHLEN];
char *p = single_update;
if (!test("f", p))
die("'%s' not found.", p);
if (isabspath(p))
die("--single-update requires relative path name.");
if (!(p[0] == '.' && p[1] == '/')) {
snprintf(regular_path_name, MAXPATHLEN, "./%s", p);
p = regular_path_name;
}
single_update = p;
}
if (!getcwd(cwd, MAXPATHLEN))
die("cannot get current directory.");
canonpath(cwd);
/*
* Decide directory (dbpath) in which gtags make tag files.
*
* Gtags create tag files at current directory by default.
* If dbpath is specified as an argument then use it.
* If the -i option specified and both GTAGS and GRTAGS exists
* at one of the candidate directories then gtags use existing
* tag files.
*/
if (iflag) {
if (argc > 0)
realpath(*argv, dbpath);
else if (!gtagsexist(cwd, dbpath, MAXPATHLEN, vflag))
strlimcpy(dbpath, cwd, sizeof(dbpath));
} else {
if (argc > 0)
realpath(*argv, dbpath);
else if (Oflag) {
char *objdir = getobjdir(cwd, vflag);
if (objdir == NULL)
die("Objdir not found.");
strlimcpy(dbpath, objdir, sizeof(dbpath));
} else
strlimcpy(dbpath, cwd, sizeof(dbpath));
}
if (iflag && (!test("f", makepath(dbpath, dbname(GTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GRTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GPATH), NULL)))) {
if (wflag)
warning("GTAGS, GRTAGS or GPATH not found. -i option ignored.");
iflag = 0;
}
if (!test("d", dbpath))
die("directory '%s' not found.", dbpath);
if (vflag)
fprintf(stderr, "[%s] Gtags started.\n", now());
/*
* load configuration file.
*/
openconf();
if (getconfb("extractmethod"))
extractmethod = 1;
strbuf_reset(sb);
if (getconfs("langmap", sb))
langmap = check_strdup(strbuf_value(sb));
strbuf_reset(sb);
if (getconfs("gtags_parser", sb))
gtags_parser = check_strdup(strbuf_value(sb));
/*
* initialize parser.
*/
if (vflag && gtags_parser)
fprintf(stderr, " Using plug-in parser.\n");
parser_init(langmap, gtags_parser);
if (vflag && file_list)
fprintf(stderr, " Using '%s' as a file list.\n", file_list);
/*
* Start statistics.
*/
init_statistics();
/*
* incremental update.
*/
if (iflag) {
/*
* Version check. If existing tag files are old enough
* gtagsopen() abort with error message.
*/
GTOP *gtop = gtags_open(dbpath, cwd, GTAGS, GTAGS_MODIFY, 0);
gtags_close(gtop);
/*
* GPATH is needed for incremental updating.
* Gtags check whether or not GPATH exist, since it may be
* removed by mistake.
*/
if (!test("f", makepath(dbpath, dbname(GPATH), NULL)))
die("Old version tag file found. Please remake it.");
(void)incremental(dbpath, cwd);
print_statistics(statistics);
exit(0);
}
/*
* create GTAGS and GRTAGS
*/
createtags(dbpath, cwd);
/*
* create idutils index.
*/
if (Iflag) {
tim = statistics_time_start("Time of creating ID");
if (vflag)
fprintf(stderr, "[%s] Creating indexes for idutils.\n", now());
strbuf_reset(sb);
strbuf_puts(sb, "mkid");
if (vflag)
strbuf_puts(sb, " -v");
strbuf_sprintf(sb, " --file='%s/ID'", dbpath);
if (vflag) {
#ifdef __DJGPP__
if (is_unixy()) /* test for 4DOS as well? */
#endif
strbuf_puts(sb, " 1>&2");
} else {
strbuf_puts(sb, " >/dev/null");
}
if (debug)
fprintf(stderr, "executing mkid like: %s\n", strbuf_value(sb));
if (system(strbuf_value(sb)))
die("mkid failed: %s", strbuf_value(sb));
if (chmod(makepath(dbpath, "ID", NULL), 0644) < 0)
die("cannot chmod ID file.");
statistics_time_end(tim);
}
if (vflag)
fprintf(stderr, "[%s] Done.\n", now());
closeconf();
strbuf_close(sb);
print_statistics(statistics);
return 0;
}
int main(int argc, char *argv[])
{
struct cap_handle *caphandle = NULL;
struct cvt_handle *cvthandle = NULL;
struct enc_handle *enchandle = NULL;
struct pac_handle *pachandle = NULL;
struct net_handle *nethandle = NULL;
struct cap_param capp;
struct cvt_param cvtp;
struct enc_param encp;
struct pac_param pacp;
struct net_param netp;
int stage = 0b00000011;
U32 vfmt = V4L2_PIX_FMT_YUYV;
U32 ofmt = V4L2_PIX_FMT_YUV420;
// set default values
capp.dev_name = "/dev/video0";
capp.width = 640;
capp.height = 480;
capp.pixfmt = vfmt;
capp.rate = 15;
cvtp.inwidth = 640;
cvtp.inheight = 480;
cvtp.inpixfmt = vfmt;
cvtp.outwidth = 640;
cvtp.outheight = 480;
cvtp.outpixfmt = ofmt;
encp.src_picwidth = 640;
encp.src_picheight = 480;
encp.enc_picwidth = 640;
encp.enc_picheight = 480;
encp.chroma_interleave = 0;
encp.fps = 15;
encp.gop = 12;
encp.bitrate = 1000;
pacp.max_pkt_len = 1400;
pacp.ssrc = 1234;
netp.serip = NULL;
netp.serport = -1;
netp.type = UDP;
char *outfile = NULL;
// options
int opt = 0;
static const char *optString = "?di:o:a:p:w:h:r:f:t:g:s:c:";
opt = getopt(argc, argv, optString);
while (opt != -1)
{
int fmt;
switch (opt)
{
case '?':
display_usage();
return 0;
case 'd':
debug = 1;
break;
case 's':
stage = atoi(optarg);
break;
case 'i':
capp.dev_name = optarg;
break;
case 'o':
outfile = optarg;
break;
case 'a':
netp.serip = optarg;
break;
case 'p':
netp.serport = atoi(optarg);
break;
case 'c':
fmt = atoi(optarg);
if (fmt == 1)
capp.pixfmt = V4L2_PIX_FMT_YUV420;
else
capp.pixfmt = V4L2_PIX_FMT_YUYV;
break;
case 'w':
capp.width = cvtp.inwidth = cvtp.outwidth = encp.src_picwidth =
encp.enc_picwidth = atoi(optarg);
break;
case 'h':
capp.height = cvtp.inheight = cvtp.outheight =
encp.src_picheight = encp.enc_picheight = atoi(optarg);
break;
case 'r':
encp.bitrate = atoi(optarg);
break;
case 'f':
capp.rate = encp.fps = atoi(optarg);
break;
case 't':
encp.chroma_interleave = atoi(optarg);
break;
case 'g':
encp.gop = atoi(optarg);
break;
default:
printf("Unknown option: %s\n", optarg);
display_usage();
return -1;
}
opt = getopt(argc, argv, optString);
}
if (outfile)
outfd = fopen(outfile, "wb");
signal(SIGINT, quit_func);
caphandle = capture_open(capp);
if (!caphandle)
{
printf("--- Open capture failed\n");
return -1;
}
if ((stage & 0b00000001) != 0)
{
cvthandle = convert_open(cvtp);
if (!cvthandle)
{
printf("--- Open convert failed\n");
return -1;
}
}
if ((stage & 0b00000010) != 0)
{
enchandle = encode_open(encp);
if (!enchandle)
{
printf("--- Open encode failed\n");
return -1;
}
}
if ((stage & 0b00000100) != 0)
{
pachandle = pack_open(pacp);
if (!pachandle)
{
printf("--- Open pack failed\n");
return -1;
}
}
if ((stage & 0b00001000) != 0)
{
if (netp.serip == NULL || netp.serport == -1)
{
printf(
"--- Server ip and port must be specified when using network\n");
return -1;
}
nethandle = net_open(netp);
if (!nethandle)
{
printf("--- Open network failed\n");
return -1;
}
}
// start capture encode loop
int ret;
void *cap_buf, *cvt_buf, *hd_buf, *enc_buf;
char *pac_buf = (char *) malloc(MAX_RTP_SIZE);
int cap_len, cvt_len, hd_len, enc_len, pac_len;
enum pic_t ptype;
struct timeval ctime, ltime;
unsigned long fps_counter = 0;
int sec, usec;
double stat_time = 0;
capture_start(caphandle); // !!! need to start capture stream!
quit = 0;
gettimeofday(<ime, NULL);
while (!quit)
{
if (debug) // print fps
{
gettimeofday(&ctime, NULL);
sec = ctime.tv_sec - ltime.tv_sec;
usec = ctime.tv_usec - ltime.tv_usec;
if (usec < 0)
{
sec--;
usec = usec + 1000000;
}
stat_time = (sec * 1000000) + usec; // diff in microsecond
if (stat_time >= 1000000) // >= 1s
{
printf("\n*** FPS: %ld\n", fps_counter);
fps_counter = 0;
ltime = ctime;
}
fps_counter++;
}
ret = capture_get_data(caphandle, &cap_buf, &cap_len);
if (ret != 0)
{
if (ret < 0) // error
{
printf("--- capture_get_data failed\n");
break;
}
else // again
{
usleep(10000);
continue;
}
}
if (cap_len <= 0)
{
printf("!!! No capture data\n");
continue;
}
if (debug)
fputc('.', stdout);
if ((stage & 0b00000001) == 0) // no convert, capture only
{
if (outfd)
fwrite(cap_buf, 1, cap_len, outfd);
continue;
}
// convert
if (capp.pixfmt == V4L2_PIX_FMT_YUV420) // no need to convert
{
cvt_buf = cap_buf;
cvt_len = cap_len;
}
else // do convert: YUYV => YUV420
{
ret = convert_do(cvthandle, cap_buf, cap_len, &cvt_buf, &cvt_len);
if (ret < 0)
{
printf("--- convert_do failed\n");
break;
}
if (cvt_len <= 0)
{
printf("!!! No convert data\n");
continue;
}
}
if (debug)
fputc('-', stdout);
if ((stage & 0b00000010) == 0) // no encode
{
if (outfd)
fwrite(cvt_buf, 1, cvt_len, outfd);
continue;
}
// encode
// fetch h264 headers first!
while ((ret = encode_get_headers(enchandle, &hd_buf, &hd_len, &ptype))
!= 0)
{
if (debug)
fputc('S', stdout);
if ((stage & 0b00000100) == 0) // no pack
{
if (outfd)
fwrite(hd_buf, 1, hd_len, outfd);
continue;
}
// pack headers
pack_put(pachandle, hd_buf, hd_len);
while (pack_get(pachandle, pac_buf, MAX_RTP_SIZE, &pac_len) == 1)
{
if (debug)
fputc('#', stdout);
if ((stage & 0b00001000) == 0) // no network
{
if (outfd)
fwrite(pac_buf, 1, pac_len, outfd);
continue;
}
// network
ret = net_send(nethandle, pac_buf, pac_len);
if (ret != pac_len)
{
printf("send pack failed, size: %d, err: %s\n", pac_len,
strerror(errno));
}
if (debug)
fputc('>', stdout);
}
}
ret = encode_do(enchandle, cvt_buf, cvt_len, &enc_buf, &enc_len,
&ptype);
if (ret < 0)
{
printf("--- encode_do failed\n");
break;
}
if (enc_len <= 0)
{
printf("!!! No encode data\n");
continue;
}
if (debug)
{
char c;
switch (ptype)
{
case PPS:
c = 'S';
break;
case SPS:
c = 'S';
break;
case I:
c = 'I';
break;
case P:
c = 'P';
break;
case B:
c = 'B';
break;
default:
c = 'N';
break;
}
fputc(c, stdout);
}
if ((stage & 0b00000100) == 0) // no pack
{
if (outfd)
fwrite(enc_buf, 1, enc_len, outfd);
continue;
}
// pack
pack_put(pachandle, enc_buf, enc_len);
while (pack_get(pachandle, pac_buf, MAX_RTP_SIZE, &pac_len) == 1)
{
if (debug)
fputc('#', stdout);
if ((stage & 0b00001000) == 0) // no network
{
if (outfd)
fwrite(pac_buf, 1, pac_len, outfd);
continue;
}
// network
ret = net_send(nethandle, pac_buf, pac_len);
if (ret != pac_len)
{
printf("send pack failed, size: %d, err: %s\n", pac_len,
strerror(errno));
}
if (debug)
fputc('>', stdout);
}
}
capture_stop(caphandle);
free(pac_buf);
if ((stage & 0b00001000) != 0)
net_close(nethandle);
if ((stage & 0b00000100) != 0)
pack_close(pachandle);
if ((stage & 0b00000010) != 0)
encode_close(enchandle);
if ((stage & 0b00000001) != 0)
convert_close(cvthandle);
capture_close(caphandle);
if (outfd)
fclose(outfd);
return 0;
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
int status = 0;
/*
* get path of following directories.
* o current directory
* o root of source tree
* o dbpath directory
*
* if GTAGS not found, exit with an error message.
*/
status = setupdbpath(0);
if (status == 0) {
cwd = get_cwd();
root = get_root();
dbpath = get_dbpath();
}
/*
* Setup GTAGSCONF and GTAGSLABEL environment variable
* according to the --gtagsconf and --gtagslabel option.
*/
preparse_options(argc, argv);
/*
* Open configuration file.
*/
openconf(root);
setenv_from_config();
logging_arguments(argc, argv);
while ((optchar = getopt_long(argc, argv, "acde:EifFgGIlL:MnoOpPqrsS:tTuvVx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
break;
case 'd':
dflag++;
break;
case 'e':
av = optarg;
break;
case 'E':
Gflag = 0;
break;
case 'f':
fflag++;
xflag++;
setcom(optchar);
break;
case 'F':
Tflag = 0;
break;
case 'g':
gflag++;
setcom(optchar);
break;
case 'G':
Gflag++;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
setcom(optchar);
break;
case 'l':
Sflag++;
scope = ".";
break;
case 'L':
file_list = optarg;
break;
case 'M':
Mflag++;
iflag = 0;
break;
case 'n':
nflag++;
if (optarg) {
if (!strcmp(optarg, "sort"))
nofilter |= SORT_FILTER;
else if (!strcmp(optarg, "path"))
nofilter |= PATH_FILTER;
} else {
nofilter = BOTH_FILTER;
}
break;
case 'o':
oflag++;
break;
case 'O':
Oflag++;
break;
case 'p':
pflag++;
setcom(optchar);
break;
case 'P':
Pflag++;
setcom(optchar);
break;
case 'q':
qflag++;
setquiet();
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
case 'S':
Sflag++;
scope = optarg;
break;
case 't':
tflag++;
break;
case 'T':
Tflag++;
break;
case 'u':
uflag++;
setcom(optchar);
break;
case 'v':
vflag++;
setverbose();
break;
case 'V':
Vflag++;
break;
case 'x':
xflag++;
break;
case OPT_USE_COLOR:
if (optarg) {
if (!strcmp(optarg, "never"))
use_color = 0;
else if (!strcmp(optarg, "always"))
use_color = 1;
else if (!strcmp(optarg, "auto"))
use_color = 2;
else
die_with_code(2, "unknown color type.");
} else {
use_color = 2;
}
break;
case OPT_ENCODE_PATH:
encode_chars = optarg;
break;
case OPT_FROM_HERE:
{
char *p = optarg;
const char *usage = "usage: global --from-here=lineno:path.";
context_lineno = p;
while (*p && isdigit(*p))
p++;
if (*p != ':')
die_with_code(2, usage);
*p++ = '\0';
if (!*p)
die_with_code(2, usage);
context_file = p;
}
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
/* These options are already parsed in preparse_options() */
break;
case OPT_MATCH_PART:
if (!strcmp(optarg, "first"))
match_part = MATCH_PART_FIRST;
else if (!strcmp(optarg, "last"))
match_part = MATCH_PART_LAST;
else if (!strcmp(optarg, "all"))
match_part = MATCH_PART_ALL;
else
die_with_code(2, "unknown part type for the --match-part option.");
break;
case OPT_PATH_CONVERT:
do_path = 1;
if (!strcmp("absolute", optarg))
convert_type = PATH_ABSOLUTE;
else if (!strcmp("relative", optarg))
convert_type = PATH_RELATIVE;
else if (!strcmp("through", optarg))
convert_type = PATH_THROUGH;
else
die("Unknown path type.");
break;
case OPT_PATH_STYLE:
path_style = optarg;
break;
case OPT_RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid"))
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "ctags-mod"))
format = FORMAT_CTAGS_MOD;
else if (!strcmp(optarg, "path"))
format = FORMAT_PATH;
else if (!strcmp(optarg, "grep"))
format = FORMAT_GREP;
else if (!strcmp(optarg, "cscope"))
format = FORMAT_CSCOPE;
else
die_with_code(2, "unknown format type for the --result option.");
break;
case OPT_SINGLE_UPDATE:
single_update = optarg;
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_version)
version(av, vflag);
if (show_help)
help();
if (dbpath == NULL)
die_with_code(-status, gtags_dbpath_error);
/*
* decide format.
* The --result option is given to priority more than the -t and -x option.
*/
if (format == 0) {
if (tflag) { /* ctags format */
format = FORMAT_CTAGS;
} else if (xflag) { /* print details */
format = FORMAT_CTAGS_X;
} else { /* print just a file name */
format = FORMAT_PATH;
}
}
/*
* GTAGSBLANKENCODE will be used in less(1).
*/
switch (format) {
case FORMAT_CTAGS_X:
case FORMAT_CTAGS_XID:
if (encode_chars == NULL && getenv("GTAGSBLANKENCODE"))
encode_chars = " \t";
break;
}
if (encode_chars) {
if (strlen(encode_chars) > 255)
die("too many encode chars.");
if (strchr(encode_chars, '/') || strchr(encode_chars, '.'))
warning("cannot encode '/' and '.' in the path. Ignored.");
set_encode_chars((unsigned char *)encode_chars);
}
if (getenv("GTAGSTHROUGH"))
Tflag++;
if (use_color) {
#if defined(_WIN32) && !defined(__CYGWIN__)
if (!(getenv("ANSICON") || LoadLibrary("ANSI32.dll")) && use_color == 2)
use_color = 0;
#endif
if (use_color == 2 && !isatty(1))
use_color = 0;
if (Vflag)
use_color = 0;
}
argc -= optind;
argv += optind;
/*
* Path filter
*/
if (do_path) {
/*
* This code is needed for globash.rc.
* This code extract path name from tag line and
* replace it with the relative or the absolute path name.
*
* By default, if we are in src/ directory, the output
* should be converted like follows:
*
* main 10 ./src/main.c main(argc, argv)\n
* main 22 ./libc/func.c main(argc, argv)\n
* v
* main 10 main.c main(argc, argv)\n
* main 22 ../libc/func.c main(argc, argv)\n
*
* Similarly, the --path-convert=absolute option specified, then
* v
* main 10 /prj/xxx/src/main.c main(argc, argv)\n
* main 22 /prj/xxx/libc/func.c main(argc, argv)\n
*/
STRBUF *ib = strbuf_open(MAXBUFLEN);
CONVERT *cv;
char *ctags_x;
if (argc < 3)
die("global --path-convert: 3 arguments needed.");
cv = convert_open(convert_type, FORMAT_CTAGS_X, argv[0], argv[1], argv[2], stdout, NOTAGS);
while ((ctags_x = strbuf_fgets(ib, stdin, STRBUF_NOCRLF)) != NULL)
convert_put(cv, ctags_x);
convert_close(cv);
strbuf_close(ib);
exit(0);
}
/*
* At first, we pickup pattern from -e option. If it is not found
* then use argument which is not option.
*/
if (!av) {
av = *argv;
/*
* global -g pattern [files ...]
* av argv
*/
if (gflag && av)
argv++;
}
if (single_update) {
if (command == 0) {
uflag++;
command = 'u';
} else if (command != 'u') {
; /* ignored */
}
}
/*
* only -c, -u, -P and -p allows no argument.
*/
if (!av) {
switch (command) {
case 'c':
case 'u':
case 'p':
case 'P':
break;
case 'f':
if (file_list)
break;
default:
usage();
break;
}
}
/*
* -u and -p cannot have any arguments.
*/
if (av) {
switch (command) {
case 'u':
case 'p':
usage();
default:
break;
}
}
if (tflag)
xflag = 0;
if (nflag > 1)
nosource = 1; /* to keep compatibility */
if (print0)
set_print0();
if (cflag && match_part == 0)
match_part = MATCH_PART_ALL;
/*
* remove leading blanks.
*/
if (!Iflag && !gflag && av)
for (; *av == ' ' || *av == '\t'; av++)
;
if (cflag && !Pflag && av && isregex(av))
die_with_code(2, "only name char is allowed with -c option.");
/*
* print dbpath or rootdir.
*/
if (pflag) {
fprintf(stdout, "%s\n", (rflag) ? root : dbpath);
exit(0);
}
/*
* incremental update of tag files.
*/
if (uflag) {
STRBUF *sb = strbuf_open(0);
char *gtags_path = usable("gtags");
if (!gtags_path)
die("gtags command not found.");
if (chdir(root) < 0)
die("cannot change directory to '%s'.", root);
#if defined(_WIN32) && !defined(__CYGWIN__)
/*
* Get around CMD.EXE's weird quoting rules by sticking another
* perceived whitespace in front (also works with Take Command).
*/
strbuf_putc(sb, ';');
#endif
strbuf_puts(sb, quote_shell(gtags_path));
strbuf_puts(sb, " -i");
if (vflag)
strbuf_puts(sb, " -v");
if (single_update) {
if (!isabspath(single_update)) {
static char regular_path_name[MAXPATHLEN];
if (rel2abs(single_update, cwd, regular_path_name, sizeof(regular_path_name)) == NULL)
die("rel2abs failed.");
single_update = regular_path_name;
}
strbuf_puts(sb, " --single-update ");
strbuf_puts(sb, quote_shell(single_update));
}
strbuf_putc(sb, ' ');
strbuf_puts(sb, quote_shell(dbpath));
if (system(strbuf_value(sb)))
exit(1);
strbuf_close(sb);
exit(0);
}
/*
* decide tag type.
*/
if (context_file) {
if (isregex(av))
die_with_code(2, "regular expression is not allowed with the --from-here option.");
db = decide_tag_by_context(av, context_file, atoi(context_lineno));
} else {
if (dflag)
db = GTAGS;
else if (rflag && sflag)
db = GRTAGS + GSYMS;
else
db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS);
}
/*
* complete function name
*/
if (cflag) {
if (Iflag)
completion_idutils(dbpath, root, av);
else if (Pflag)
completion_path(dbpath, av);
else
completion(dbpath, root, av, db);
exit(0);
}
/*
* make local prefix.
* local prefix must starts with './' and ends with '/'.
*/
if (Sflag) {
STRBUF *sb = strbuf_open(0);
static char buf[MAXPATHLEN];
const char *path = scope;
/*
* normalize the path of scope directory.
*/
if (!test("d", path))
die("'%s' not found or not a directory.", scope);
if (!isabspath(path))
path = makepath(cwd, path, NULL);
if (realpath(path, buf) == NULL)
die("cannot get real path of '%s'.", scope);
if (!in_the_project(buf))
die("'%s' is out of the source project.", scope);
scope = buf;
/*
* make local prefix.
*/
strbuf_putc(sb, '.');
if (strcmp(root, scope) != 0) {
const char *p = scope + strlen(root);
if (*p != '/')
strbuf_putc(sb, '/');
strbuf_puts(sb, p);
}
strbuf_putc(sb, '/');
localprefix = check_strdup(strbuf_value(sb));
strbuf_close(sb);
#ifdef DEBUG
fprintf(stderr, "root=%s\n", root);
fprintf(stderr, "cwd=%s\n", cwd);
fprintf(stderr, "localprefix=%s\n", localprefix);
#endif
}
/*
* convert the file-list path into an absolute path.
*/
if (file_list && strcmp(file_list, "-") && !isabspath(file_list)) {
static char buf[MAXPATHLEN];
if (realpath(file_list, buf) == NULL)
die("'%s' not found.", file_list);
file_list = buf;
}
/*
* decide path conversion type.
*/
if (nofilter & PATH_FILTER)
type = PATH_THROUGH;
else if (aflag)
type = PATH_ABSOLUTE;
else
type = PATH_RELATIVE;
if (path_style) {
if (!strcmp(path_style, "relative"))
type = PATH_RELATIVE;
else if (!strcmp(path_style, "absolute"))
type = PATH_ABSOLUTE;
else if (!strcmp(path_style, "through"))
type = PATH_THROUGH;
else if (!strcmp(path_style, "shorter"))
type = PATH_SHORTER;
else if (!strcmp(path_style, "abslib")) {
type = PATH_RELATIVE;
abslib++;
} else
die("invalid path style.");
}
/*
* exec lid(idutils).
*/
if (Iflag) {
chdir(root);
idutils(av, dbpath);
}
/*
* search pattern (regular expression).
*/
else if (gflag) {
chdir(root);
grep(av, argv, dbpath);
}
/*
* locate paths including the pattern.
*/
else if (Pflag) {
chdir(root);
pathlist(av, dbpath);
}
/*
* parse source files.
*/
else if (fflag) {
chdir(root);
parsefile(argv, cwd, root, dbpath, db);
}
/*
* tag search.
*/
else {
tagsearch(av, cwd, root, dbpath, db);
}
return 0;
}
/**
* grep: @NAME{grep} pattern
*
* @param[in] pattern @NAME{POSIX} regular expression
* @param argv
* @param dbpath
*/
void
grep(const char *pattern, char *const *argv, const char *dbpath)
{
FILE *fp;
CONVERT *cv;
GFIND *gp = NULL;
STRBUF *ib = strbuf_open(MAXBUFLEN);
const char *path;
char encoded_pattern[IDENTLEN];
const char *buffer;
int linenum, count;
int flags = 0;
int target = GPATH_SOURCE;
regex_t preg;
int user_specified = 1;
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
/*
* literal search available?
*/
if (!literal) {
const char *p = pattern;
int normal = 1;
for (; *p; p++) {
if (!(isalpha(*p) || isdigit(*p) || isblank(*p) || *p == '_')) {
normal = 0;
break;
}
}
if (normal)
literal = 1;
}
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (literal) {
literal_comple(pattern);
} else {
if (!Gflag)
flags |= REG_EXTENDED;
if (iflag)
flags |= REG_ICASE;
if (regcomp(&preg, pattern, flags) != 0)
die("invalid regular expression.");
}
cv = convert_open(type, format, root, cwd, dbpath, stdout, NOTAGS);
cv->tag_for_display = encoded_pattern;
count = 0;
if (*argv && file_list)
args_open_both(argv, file_list);
else if (*argv)
args_open(argv);
else if (file_list)
args_open_filelist(file_list);
else {
args_open_gfind(gp = gfind_open(dbpath, localprefix, target));
user_specified = 0;
}
while ((path = args_read()) != NULL) {
if (user_specified) {
static char buf[MAXPATHLEN];
if (normalize(path, get_root_with_slash(), cwd, buf, sizeof(buf)) == NULL) {
warning("'%s' is out of the source project.", path);
continue;
}
if (test("d", buf)) {
warning("'%s' is a directory. Ignored.", path);
continue;
}
if (!test("f", buf)) {
warning("'%s' not found. Ignored.", path);
continue;
}
path = buf;
}
if (Sflag && !locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
if (literal) {
int n = literal_search(cv, path);
if (n > 0)
count += n;
} else {
if (!(fp = fopen(path, "r")))
die("cannot open file '%s'.", path);
linenum = 0;
while ((buffer = strbuf_fgets(ib, fp, STRBUF_NOCRLF)) != NULL) {
int result = regexec(&preg, buffer, 0, 0, 0);
linenum++;
if ((!Vflag && result == 0) || (Vflag && result != 0)) {
count++;
if (format == FORMAT_PATH) {
convert_put_path(cv, NULL, path);
break;
} else {
convert_put_using(cv, pattern, path, linenum, buffer,
(user_specified) ? NULL : gp->dbop->lastdat);
}
}
}
fclose(fp);
}
}
args_close();
convert_close(cv);
strbuf_close(ib);
if (literal == 0)
regfree(&preg);
if (vflag) {
print_count(count);
fprintf(stderr, " (no index used).\n");
}
}