int main(int argc, char **argv)
{
initialize();
#ifdef __AFL_INIT
// Enable AFL deferred forkserver mode. Requires compilation using
// afl-clang-fast++. See fuzzing.md for details.
__AFL_INIT();
#endif
#ifdef __AFL_LOOP
// Enable AFL persistent mode. Requires compilation using afl-clang-fast++.
// See fuzzing.md for details.
int ret = 0;
while (__AFL_LOOP(1000)) {
std::vector<uint8_t> buffer;
if (!read_stdin(buffer)) {
continue;
}
ret = test_one_input(buffer);
}
return ret;
#else
std::vector<uint8_t> buffer;
if (!read_stdin(buffer)) {
return 0;
}
return test_one_input(buffer);
#endif
}
int FAR _export
gsdll_callback(int message, char FAR *str, unsigned long count)
{
char buf[256];
switch (message) {
case GSDLL_POLL:
// Don't check message queue because we don't
// create any windows.
// May want to return error code if abort wanted
break;
case GSDLL_STDIN:
return read_stdin(str, count);
case GSDLL_STDOUT:
fwrite(str, 1, count, stdout);
fflush(stdout);
return count;
case GSDLL_DEVICE:
if (count) {
sprintf(buf, "mswindll device not supported in this version of Ghostscript\n");
fputs(buf, stdout);
}
break;
case GSDLL_SYNC:
break;
case GSDLL_PAGE:
break;
case GSDLL_SIZE:
break;
default:
sprintf(buf,"Callback: Unknown message=%d\n",message);
fputs(buf, stdout);
break;
}
return 0;
}
static void stdin_cmd_poll(rarch_cmd_t *handle)
{
if (!handle->stdin_enable)
return;
size_t ret = read_stdin(handle->stdin_buf + handle->stdin_buf_ptr, STDIN_BUF_SIZE - handle->stdin_buf_ptr - 1);
if (ret == 0)
return;
handle->stdin_buf_ptr += ret;
handle->stdin_buf[handle->stdin_buf_ptr] = '\0';
char *last_newline = strrchr(handle->stdin_buf, '\n');
if (!last_newline)
{
// We're receiving bogus data in pipe (no terminating newline),
// flush out the buffer.
if (handle->stdin_buf_ptr + 1 >= STDIN_BUF_SIZE)
{
handle->stdin_buf_ptr = 0;
handle->stdin_buf[0] = '\0';
}
return;
}
*last_newline++ = '\0';
ptrdiff_t msg_len = last_newline - handle->stdin_buf;
parse_msg(handle, handle->stdin_buf);
memmove(handle->stdin_buf, last_newline, handle->stdin_buf_ptr - msg_len);
handle->stdin_buf_ptr -= msg_len;
}
static int talker(int socketDescriptor, t_entry **entry)
{
char msg[MAX_MSG];
int i;
get_connection(socketDescriptor);
while (strcmp(msg, "quit") != 0)
{
bzero(msg, sizeof(msg));
if ((read_stdin(msg)) == EXIT_FAILURE)
return (EXIT_FAILURE);
for (i = 0; entry[i]->cmd &&
strncmp(entry[i]->cmd, msg, strlen(entry[i]->cmd)) != 0; ++i);
if (entry[i]->cmd != NULL)
{
if ((entry[i]->fptr(msg, socketDescriptor)) == EXIT_FAILURE)
return (EXIT_FAILURE);
}
else
{
if ((dprintf(socketDescriptor, "%s", msg)) == -1)
return (my_perror("dprintf"));
}
get_srv_ret(socketDescriptor);
}
return (EXIT_SUCCESS);
}
int main(int ac, char **av)
{
t_env env;
if (!(isatty(0)))
error_quit("Invalid stdin, please run from terminal");
g_env = &env;
env.old_width = 0;
env.old_height = 0;
env.list_size = ac - 1;
env.items = NULL;
get_tty_fd(&env);
build_list(&env, ac, av);
env.curr = env.items;
init_signals();
tgetent(0, getenv("TERM"));
if (!(env.caps = malloc(sizeof(*env.caps))))
error_quit("Failed to malloc env caps");
init_caps(env.caps);
key_codes_init(&env);
terminal_catch();
env.fd = 2;
while (1)
{
draw_list(&env);
read_stdin(&env);
}
}
int
main (int argc, char **argv) {
uint32_t **freq = NULL;
uint32_t *cur = NULL;
char *buf = NULL;
char *format = NULL;
char *opt = 0;
int cfirst = 1;
if (1 == argc && 1 == isatty(0)) { return usage(), 1; }
else if (ferror(stdin)) { return 1; }
if (argc > 1) {
while (*argv++) {
opt = argv[0];
switch (opt[0]) {
case '-':
switch (opt[1]) {
case 'h': return usage(), 0;
case 'V': return printf("%s\n", CHFREQ_VERSION), 0;
case 'f': opt = *argv++; format = *argv++; break;
}
break;
}
}
}
if (NULL == format) {
format = "%c | %d";
}
// get order of format
{
char ch = 0;
int i = 0;
while ('\0' != (ch = format[i++])) {
if ('%' == ch) {
if ('c' == format[i]) { cfirst = 1; break; }
else { cfirst = 0; break; }
}
}
}
if (1 == isatty(0)) { return usage(), 1; }
else if (ferror(stdin)) { return 1; }
else {
do {
buf = read_stdin();
if (NULL == buf) { return 1; }
freq = chfreq(buf);
for (int i = 0; (cur = freq[i]); ++i) {
if (1 == cfirst) { printf(format, cur[0], cur[1]); }
else { printf(format, cur[1], cur[0]); }
printf("\n");
}
} while (NULL != buf);
}
return 0;
}
int main(int argc, const char *const *argv)
{
struct timeval *tv, tvbuf;
adns_query qu;
void *qun_v;
adns_answer *answer;
int r, maxfd;
fd_set readfds, writefds, exceptfds;
const char *arg;
ensure_adns_init();
while ((arg= *++argv)) process_optarg(arg,&argv,0);
if (!ov_pipe && !ads) usageerr("no domains given, and -f/--pipe not used; try --help");
for (;;)
{
for (;;)
{
qu= ov_asynch ? 0 : outstanding.head ? outstanding.head->qu : 0;
r= adns_check(ads,&qu,&answer,&qun_v);
if ((r == EAGAIN) || (r == EWOULDBLOCK)) break;
if (r == ESRCH)
{
if (!ov_pipe) goto x_quit;
else break;
}
assert(!r);
query_done(qun_v,answer);
}
maxfd= 0;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&exceptfds);
if (ov_pipe)
{
maxfd= 1;
FD_SET(0,&readfds);
}
tv= 0;
adns_beforeselect(ads, &maxfd, &readfds,&writefds,&exceptfds, &tv,&tvbuf,0);
ADNS_CLEAR_ERRNO;
r= select(maxfd, &readfds,&writefds,&exceptfds, tv);
ADNS_CAPTURE_ERRNO;
if (r == -1)
{
if (errno == EINTR) continue;
sysfail("select",errno);
}
adns_afterselect(ads, maxfd, &readfds,&writefds,&exceptfds, 0);
if (ov_pipe && FD_ISSET(0,&readfds)) read_stdin();
}
x_quit:
if (fclose(stdout)) outerr();
quitnow(rcode);
}
int main(int argc, char *argv[])
{
int sock;
struct sockaddr_in addr;
int port = get_port(argc, argv);
char server_address_string[16];
char buf[BUF_SIZE];
char repeat = 1;
int id;
set_address(argc, argv, server_address_string, LENGTH_OF(server_address_string));
srand(time(NULL));
id = rand();
sock = socket(AF_INET, SOCK_STREAM, 0);
if(WRONG_SOC(sock)) {
perror("socket");
exit(1);
}
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
/* addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); */
addr.sin_addr.s_addr = inet_addr(server_address_string);
if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("connect");
exit(2);
}
printf("%s:%d, ID: %d\n", server_address_string, port, id);
send(sock, &id, sizeof(id), EMPTY_FLAGS);
while(repeat) {
printf("-> ");
read_stdin(buf, LENGTH_OF(buf));
if(strlen(buf) == 0) continue;
if(!strncmp(buf, "close", LENGTH_OF(buf))) repeat = 0;
send_to(sock, buf);
// download file if its exists
if(strstr(buf, "download") && receive_int(sock)) {
receive_file(sock);
printf("%s\n", FILE_DOWNLOADED_MSG);
continue;
}
// prints info or error mesages
receive_and_print_msg(sock);
}
close(sock);
return 0;
}
/* Cat clone */
int main(int argc, char **argv) {
int i;
if (argc < 2) {
read_stdin();
return 0;
}
for (i=1 ; i<argc ; i++) {
print_file(argv[i]);
}
return 0;
}
int check_fds(fd_set *fd_read, int *fd,
void (*fptr[7])(char buf[515], int *), char *tab[7])
{
if (FD_ISSET(0, fd_read))
if (read_stdin(fd, fptr, tab) == -1)
return (-1);
if (*fd != -1 && FD_ISSET(*fd, fd_read))
if (read_socket(fd) == -1)
return (-1);
return (0);
}
static void MojoGui_stdio_msgbox(const char *title, const char *text)
{
char buf[128];
char *fmt = xstrdup(_("NOTICE: %0\n[hit enter]"));
char *msg = format(fmt, text);
printf("%s\n", msg);
free(msg);
free(fmt);
fflush(stdout);
read_stdin(buf, sizeof (buf));
} // MojoGui_stdio_msgbox
int check_fd(t_env *e)
{
if (FD_ISSET(e->fd.fd, &e->fd_read))
{
return (read_fd(e));
}
if (FD_ISSET(0, &e->fd_read))
{
read_stdin(e);
}
return (1);
}
int main(int argc, char** argv) {
char* content;
if (argc > 1) { content = argv[1]; }
else { content = read_stdin(); }
treebank_tokens_t* tokens = treebank_tokenize(content);
int num_tokens = tokens->length;
for (int i = 0; i < num_tokens; i++) printf("%s ",
tokens->token_array[i]);
treebank_tokens_free(tokens);
printf("\n");
return 0;
}
int main(int argc, char **argv) {
entry** table = mk_table();
if (argc > 1 ) {
for (int i=1; i < argc; i++) {
read_file(argv[i], table);
}
} else {
read_stdin(table);
}
print_table(table);
del_table(table);
return 0;
}
static MojoGuiYNAN MojoGui_stdio_promptynan(const char *title, const char *txt,
boolean defval)
{
MojoGuiYNAN retval = MOJOGUI_NO;
if (!feof(stdin))
{
char *fmt = xstrdup(_("%0\n[y/n/Always/Never]: "));
char *msg = format(fmt, txt);
char *localized_no = xstrdup(_("N"));
char *localized_yes = xstrdup(_("Y"));
char *localized_always = xstrdup(_("Always"));
char *localized_never = xstrdup(_("Never"));
boolean getout = false;
char buf[128];
while (!getout)
{
int rc = 0;
getout = true; // we may reset this later.
printf("%s\n", msg);
fflush(stdout);
rc = read_stdin(buf, sizeof (buf));
if (rc < 0)
retval = MOJOGUI_NO;
else if (rc == 0)
retval = (defval) ? MOJOGUI_YES : MOJOGUI_NO;
else if (strcasecmp(buf, localized_no) == 0)
retval = MOJOGUI_NO;
else if (strcasecmp(buf, localized_yes) == 0)
retval = MOJOGUI_YES;
else if (strcasecmp(buf, localized_always) == 0)
retval = MOJOGUI_ALWAYS;
else if (strcasecmp(buf, localized_never) == 0)
retval = MOJOGUI_NEVER;
else
getout = false; // try again.
} // while
free(localized_never);
free(localized_always);
free(localized_yes);
free(localized_no);
free(msg);
free(fmt);
} // if
return retval;
} // MojoGui_stdio_promptynan
int
main(int argc , char * argv[])
{
int ch;
const char * proto = NULL;
const char * message = NULL;
const char * datafile = NULL;
int mode = 0;
while ((ch = getopt(argc, argv, "hDp:m:d:")) != -1) {
switch(ch) {
case 'h':
usage(argv[0]);
return 0;
case 'p':
proto = optarg;
break;
case 'm':
message = optarg;
break;
case 'd':
datafile = optarg;
break;
case 'D':
mode = 10;
break;
default:
usage(argv[0]);
return 1;
}
}
if (proto == NULL || message == NULL) {
usage(argv[0]);
return 1;
}
struct pbc_slice data;
if (datafile == NULL) {
read_stdin(mode, &data);
} else {
read_file(datafile , &data);
}
dump(proto , message , &data);
return 0;
}
int main(int argc, char **argv)
{
int n;
char **in;
char *path;
option_parse(argc, argv);
agurim_init();
argc -= optind;
argv += optind;
if (argc == 0){
/* stdin supports re-aggregation format only. */
if (query.outfmt != REAGGREGATION)
usage();
else
read_stdin();
}
again:
n = argc;
in = argv;
while (n > 0) {
path = *in;
if (is_dir(path))
read_dir(path);
else
read_file(path);
++in;
--n;
}
if (inparam.mode == HHH_MAIN_MODE){
hhh_run();
if (query.outfmt != REAGGREGATION) {
/* reset internal parameters for text processing */
param_set_nextmode();
/* goto the second pass */
goto again;
}
} else {
plot_run();
}
agurim_finish();
return (0);
}
static char *ask_password(void) {
char *passwd, *r;
passwd = malloc(128 + 1);
if (passwd == NULL)
return NULL;
printf("[%s] Enter password: ", arg_username);
r = read_stdin(passwd, 128, false);
if (r == NULL) {
free(passwd);
return NULL;
}
return passwd;
}
static char *ask_username(void) {
char *username, *r;
username = malloc(128 + 1);
if (username == NULL)
return NULL;
printf("Enter username: ");
r = read_stdin(username, 128, true);
if (r == NULL) {
free(username);
return NULL;
}
return username;
}
void mgrep(const regex_t* preg, flags_t flags) {
if (flags.mmap) {
struct stat sb;
if (fstat(0, &sb) == -1) {
perror ("fstat");
exit(1);
}
char *p =mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, 0, 0);
if (p == MAP_FAILED) {
perror("mmap");
exit(1);
}
readlines(preg, p, sb.st_size);
munmap(p,sb.st_size);
} else {
read_stdin(preg);
}
}
static void
event_loop(void) {
int xfd, nbits, dr=0;
fd_set rmask;
// Assign connection number for the specified display
xfd = ConnectionNumber(dzen.dpy);
while(dzen.running) {
FD_ZERO(&rmask); // Clear newly declared set
FD_SET(xfd, &rmask); // Assign the fd to a set
if(dr != -2) //TODO (PM) Won't this statement always return true?
FD_SET(STDIN_FILENO, &rmask);
//TODO (PM) This would make a second call to the same function.
// Can more than one fd be assigned to a set?
while(XPending(dzen.dpy))
handle_xev();
nbits = select(xfd+1, &rmask, NULL, NULL, NULL);
if (nbits != -1) {
//TODO (PM) Again, dr has only been assigned the value, zero
if (dr != -2 && FD_ISSET(STDIN_FILENO, &rmask)) {
if ((dr = read_stdin()) == -1)
return;
handle_newl();
}
if (dr == -2 && dzen.timeout > 0) {
/* set an alarm to kill us after the timeout */
struct itimerval t;
memset(&t, 0, sizeof t);
t.it_value.tv_sec = dzen.timeout;
t.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &t, NULL);
}
if (FD_ISSET(xfd, &rmask))
handle_xev();
}
else {
perror("select"); //TODO (PM) Consolidate error handling
exit(EXIT_FAILURE);
}
}
return;
}
static boolean MojoGui_stdio_promptyn(const char *title, const char *text,
boolean defval)
{
boolean retval = false;
if (!feof(stdin))
{
const char *_fmt = ((defval) ? _("%0 [Y/n]: ") : _("%0 [y/N]: "));
char *fmt = xstrdup(_fmt);
char *msg = format(fmt, text);
char *localized_no = xstrdup(_("N"));
char *localized_yes = xstrdup(_("Y"));
boolean getout = false;
char buf[128];
while (!getout)
{
int rc = 0;
getout = true; // we may reset this later.
printf("%s", msg);
fflush(stdout);
rc = read_stdin(buf, sizeof (buf));
if (rc < 0)
retval = false;
else if (rc == 0)
retval = defval;
else if (strcasecmp(buf, localized_no) == 0)
retval = false;
else if (strcasecmp(buf, localized_yes) == 0)
retval = true;
else
getout = false; // try again.
} // while
free(localized_yes);
free(localized_no);
free(msg);
free(fmt);
} // if
return retval;
} // MojoGui_stdio_promptyn
static int readstr(const char *prompt, char *buf, int len,
boolean back, boolean fwd)
{
// !!! FIXME: if read_stdin() returns -1, we return 0, which makes it
// !!! FIXME: indistinguishable from "user hit enter" ... maybe we should
// !!! FIXME: abort in read_stdin() if i/o fails?
int retval = 0;
char *backstr = (back) ? xstrdup(_("back")) : NULL;
if (prompt != NULL)
printf("%s\n", prompt);
if (back)
{
char *fmt = xstrdup(_("Type '%0' to go back."));
char *msg = format(fmt, backstr);
printf("%s\n", msg);
free(msg);
free(fmt);
} // if
if (fwd)
{
printf("%s", _("Press enter to continue."));
printf("\n");
} // if
printf("%s",_("> "));
fflush(stdout);
if ((retval = read_stdin(buf, len)) >= 0)
{
if ((back) && (strcmp(buf, backstr) == 0)) // !!! FIXME: utf8casecmp?
retval = -1;
} // if
free(backstr);
return retval;
} // readstr
int main(int ac, char **av)
{
int fd[ac];
int return_val[ac];
char *line;
int i;
line = NULL;
if (ac == 1)
{
read_stdin(line);
return (0);
}
i = 0;
while (++i < ac)
{
fd[i - 1] = open(av[i], O_RDONLY);
if (fd[i - 1] == -1)
{
ft_putendl("erreur lors de l'ouverture du fichier");
return (-1);
}
return_val[i - 1] = 1;
}
i = 0;
while (!is_finished(return_val, ac))
{
return_val[i] = get_next_line(fd[i], &line);
if (return_val[i] == 1)
ft_putendl(line);
i++;
if (i == ac - 1)
i = 0;
free(line);
}
}
int main(int argc, char **argv)
{
struct extent_info_t *extent_info;
if(argc==1) {
fprintf(stderr, "Usage: %s <dev name> [<number of extents to print>]\n", argv[0]);
exit(1);
}
parse_lv_name(argv[1]);
if(argc>2)
ext_to_print = atoi(argv[2]);
extent_info = calloc(sizeof(struct extent_info_t), EXTENTS);
if (!extent_info) {
fprintf(stderr, "can't allocate memory!\n");
exit(1);
}
uint64_t now = time(NULL);
extent_info = read_stdin(now, extent_info);
printf("individual extent score:\n");
for(size_t i=0; i<EXTENTS; i++)
if(extent_info[i].reads[0] || extent_info[i].writes[0]) {
printf("%lu: r: %u, w:%u\n", i, get_read_score(&extent_info[i]), get_write_score(&extent_info[i]));
// print_io(&extent_info[i]);
}
print_extents(extent_info);
free(extent_info);
return 0;
}
static void
event_loop(void) {
int xfd, ret, dr=0;
fd_set rmask;
xfd = ConnectionNumber(dzen.dpy);
while(dzen.running) {
FD_ZERO(&rmask);
FD_SET(xfd, &rmask);
if(dr != -2)
FD_SET(STDIN_FILENO, &rmask);
while(XPending(dzen.dpy))
handle_xev();
ret = select(xfd+1, &rmask, NULL, NULL, NULL);
if(ret) {
if(dr != -2 && FD_ISSET(STDIN_FILENO, &rmask)) {
if((dr = read_stdin()) == -1)
return;
handle_newl();
}
if(dr == -2 && dzen.timeout > 0) {
/* set an alarm to kill us after the timeout */
struct itimerval t;
memset(&t, 0, sizeof t);
t.it_value.tv_sec = dzen.timeout;
t.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &t, NULL);
}
if(FD_ISSET(xfd, &rmask))
handle_xev();
}
}
return;
}
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
djpeg_dest_ptr dest_mgr = NULL;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "djpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG decompression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Insert custom marker processor for COM and APP12.
* APP12 is used by some digital camera makers for textual info,
* so we provide the ability to display it as text.
* If you like, additional APPn marker types can be selected for display,
* but don't try to override APP0 or APP14 this way (see libjpeg.doc).
*/
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Scan command line to find file names. */
/* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
* (Exception: tracing level set here controls verbosity for COM markers
* found during jpeg_read_header...)
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Specify data source for decompression */
jpeg_stdio_src(&cinfo, input_file);
/* Read file header, set default decompression parameters */
(void) jpeg_read_header(&cinfo, TRUE);
/* Adjust default decompression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Initialize the output module now to let it override any crucial
* option settings (for instance, GIF wants to force color quantization).
*/
switch (requested_fmt) {
#ifdef BMP_SUPPORTED
case FMT_BMP:
dest_mgr = jinit_write_bmp(&cinfo, FALSE);
break;
case FMT_OS2:
dest_mgr = jinit_write_bmp(&cinfo, TRUE);
break;
#endif
#ifdef GIF_SUPPORTED
case FMT_GIF:
dest_mgr = jinit_write_gif(&cinfo);
break;
#endif
#ifdef PPM_SUPPORTED
case FMT_PPM:
dest_mgr = jinit_write_ppm(&cinfo);
break;
#endif
#ifdef RLE_SUPPORTED
case FMT_RLE:
dest_mgr = jinit_write_rle(&cinfo);
break;
#endif
#ifdef TARGA_SUPPORTED
case FMT_TARGA:
dest_mgr = jinit_write_targa(&cinfo);
break;
#endif
default:
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
break;
}
dest_mgr->output_file = output_file;
/* Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* Write output file header */
(*dest_mgr->start_output) (&cinfo, dest_mgr);
/* Process data */
while (cinfo.output_scanline < cinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
#ifdef PROGRESS_REPORT
/* Hack: count final pass as done in case finish_output does an extra pass.
* The library won't have updated completed_passes.
*/
progress.pub.completed_passes = progress.pub.total_passes;
#endif
/* Finish decompression and release memory.
* I must do it in this order because output module has allocated memory
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
*/
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
(void) jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
/*
sockfdp is a pointer to an established stream or CURL_SOCKET_BAD
if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must
accept()
*/
static bool juggle(curl_socket_t *sockfdp,
curl_socket_t listenfd,
enum sockmode *mode)
{
struct timeval timeout;
fd_set fds_read;
fd_set fds_write;
fd_set fds_err;
curl_socket_t sockfd = CURL_SOCKET_BAD;
int maxfd = -99;
ssize_t rc;
ssize_t nread_socket;
ssize_t bytes_written;
ssize_t buffer_len;
int error = 0;
/* 'buffer' is this excessively large only to be able to support things like
test 1003 which tests exceedingly large server response lines */
unsigned char buffer[17010];
char data[16];
if(got_exit_signal) {
logmsg("signalled to die, exiting...");
return FALSE;
}
#ifdef HAVE_GETPPID
/* As a last resort, quit if sockfilt process becomes orphan. Just in case
parent ftpserver process has died without killing its sockfilt children */
if(getppid() <= 1) {
logmsg("process becomes orphan, exiting");
return FALSE;
}
#endif
timeout.tv_sec = 120;
timeout.tv_usec = 0;
FD_ZERO(&fds_read);
FD_ZERO(&fds_write);
FD_ZERO(&fds_err);
FD_SET((curl_socket_t)fileno(stdin), &fds_read);
switch(*mode) {
case PASSIVE_LISTEN:
/* server mode */
sockfd = listenfd;
/* there's always a socket to wait for */
FD_SET(sockfd, &fds_read);
maxfd = (int)sockfd;
break;
case PASSIVE_CONNECT:
sockfd = *sockfdp;
if(CURL_SOCKET_BAD == sockfd) {
/* eeek, we are supposedly connected and then this cannot be -1 ! */
logmsg("socket is -1! on %s:%d", __FILE__, __LINE__);
maxfd = 0; /* stdin */
}
else {
/* there's always a socket to wait for */
FD_SET(sockfd, &fds_read);
#ifdef USE_WINSOCK
FD_SET(sockfd, &fds_err);
#endif
maxfd = (int)sockfd;
}
break;
case ACTIVE:
sockfd = *sockfdp;
/* sockfd turns CURL_SOCKET_BAD when our connection has been closed */
if(CURL_SOCKET_BAD != sockfd) {
FD_SET(sockfd, &fds_read);
#ifdef USE_WINSOCK
FD_SET(sockfd, &fds_err);
#endif
maxfd = (int)sockfd;
}
else {
logmsg("No socket to read on");
maxfd = 0;
}
break;
case ACTIVE_DISCONNECT:
logmsg("disconnected, no socket to read on");
maxfd = 0;
sockfd = CURL_SOCKET_BAD;
break;
} /* switch(*mode) */
do {
/* select() blocking behavior call on blocking descriptors please */
rc = select(maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout);
if(got_exit_signal) {
logmsg("signalled to die, exiting...");
return FALSE;
}
} while((rc == -1) && ((error = errno) == EINTR));
if(rc < 0) {
logmsg("select() failed with error: (%d) %s",
error, strerror(error));
return FALSE;
}
if(rc == 0)
/* timeout */
return TRUE;
if(FD_ISSET(fileno(stdin), &fds_read)) {
/* read from stdin, commands/data to be dealt with and possibly passed on
to the socket
protocol:
4 letter command + LF [mandatory]
4-digit hexadecimal data length + LF [if the command takes data]
data [the data being as long as set above]
Commands:
DATA - plain pass-thru data
*/
if(!read_stdin(buffer, 5))
return FALSE;
logmsg("Received %c%c%c%c (on stdin)",
buffer[0], buffer[1], buffer[2], buffer[3] );
if(!memcmp("PING", buffer, 4)) {
/* send reply on stdout, just proving we are alive */
if(!write_stdout("PONG\n", 5))
return FALSE;
}
else if(!memcmp("PORT", buffer, 4)) {
/* Question asking us what PORT number we are listening to.
Replies to PORT with "IPv[num]/[port]" */
sprintf((char *)buffer, "%s/%hu\n", ipv_inuse, port);
buffer_len = (ssize_t)strlen((char *)buffer);
snprintf(data, sizeof(data), "PORT\n%04zx\n", buffer_len);
if(!write_stdout(data, 10))
return FALSE;
if(!write_stdout(buffer, buffer_len))
return FALSE;
}
else if(!memcmp("QUIT", buffer, 4)) {
/* just die */
logmsg("quits");
return FALSE;
}
else if(!memcmp("DATA", buffer, 4)) {
/* data IN => data OUT */
if(!read_stdin(buffer, 5))
return FALSE;
buffer[5] = '\0';
buffer_len = (ssize_t)strtol((char *)buffer, NULL, 16);
if (buffer_len > (ssize_t)sizeof(buffer)) {
logmsg("ERROR: Buffer size (%zu bytes) too small for data size "
"(%zd bytes)", sizeof(buffer), buffer_len);
return FALSE;
}
logmsg("> %zd bytes data, server => client", buffer_len);
if(!read_stdin(buffer, buffer_len))
return FALSE;
lograw(buffer, buffer_len);
if(*mode == PASSIVE_LISTEN) {
logmsg("*** We are disconnected!");
if(!write_stdout("DISC\n", 5))
return FALSE;
}
else {
/* send away on the socket */
bytes_written = swrite(sockfd, buffer, buffer_len);
if(bytes_written != buffer_len) {
logmsg("Not all data was sent. Bytes to send: %zd sent: %zd",
buffer_len, bytes_written);
}
}
}
else if(!memcmp("DISC", buffer, 4)) {
/* disconnect! */
if(!write_stdout("DISC\n", 5))
return FALSE;
if(sockfd != CURL_SOCKET_BAD) {
logmsg("====> Client forcibly disconnected");
sclose(sockfd);
*sockfdp = CURL_SOCKET_BAD;
if(*mode == PASSIVE_CONNECT)
*mode = PASSIVE_LISTEN;
else
*mode = ACTIVE_DISCONNECT;
}
else
logmsg("attempt to close already dead connection");
return TRUE;
}
}
if((sockfd != CURL_SOCKET_BAD) && (FD_ISSET(sockfd, &fds_read)) ) {
curl_socket_t newfd = CURL_SOCKET_BAD; /* newly accepted socket */
if(*mode == PASSIVE_LISTEN) {
/* there's no stream set up yet, this is an indication that there's a
client connecting. */
newfd = accept(sockfd, NULL, NULL);
if(CURL_SOCKET_BAD == newfd) {
error = SOCKERRNO;
logmsg("accept(%d, NULL, NULL) failed with error: (%d) %s",
sockfd, error, strerror(error));
}
else {
logmsg("====> Client connect");
if(!write_stdout("CNCT\n", 5))
return FALSE;
*sockfdp = newfd; /* store the new socket */
*mode = PASSIVE_CONNECT; /* we have connected */
}
return TRUE;
}
/* read from socket, pass on data to stdout */
nread_socket = sread(sockfd, buffer, sizeof(buffer));
if(nread_socket > 0) {
snprintf(data, sizeof(data), "DATA\n%04zx\n", nread_socket);
if(!write_stdout(data, 10))
return FALSE;
if(!write_stdout(buffer, nread_socket))
return FALSE;
logmsg("< %zd bytes data, client => server", nread_socket);
lograw(buffer, nread_socket);
}
if(nread_socket <= 0
#ifdef USE_WINSOCK
|| FD_ISSET(sockfd, &fds_err)
#endif
) {
logmsg("====> Client disconnect");
if(!write_stdout("DISC\n", 5))
return FALSE;
sclose(sockfd);
*sockfdp = CURL_SOCKET_BAD;
if(*mode == PASSIVE_CONNECT)
*mode = PASSIVE_LISTEN;
else
*mode = ACTIVE_DISCONNECT;
return TRUE;
}
}
return TRUE;
}
int
main (int argc, char **argv)
{
int i;
int lo_fd;
fd_set rfds;
struct timeval tv;
int retval;
int done = 0;
int loadOK = 0;
funcion = 0;
gui.Pexit = 0 ;
gui.Pexitprogram = 0;
gui.ready = 0;
gui.D_Vol_c = 0;
gui.D_Tune_c = 0;
gui.D_Portamento_c = 0;
gui.D_LFO_Volume_c = 0;
gui.D_LFO_Frequency_c = 0;
gui.D_LFO_Delay_c = 0;
gui.D_LFO_Wave_c = 0;
gui.cop = 0;
for (i = 0; i < 6; i++)
{
gui.D_Wave_c[i] = 0;
gui.D_H_c[i] = 0;
gui.D_HF_c[i] = 0;
gui.D_OVol_c[i] = 0;
gui.D_pLFO_c[i] = 0;
gui.D_Attack_c[i] = 0;
gui.D_Decay_c[i] = 0;
gui.D_Sustain_c[i] = 0;
gui.D_Release_c[i] = 0;
}
gui.D_Ftype_c = 0;
gui.D_Fgain_c = 0;
gui.D_Fcutoff_c = 0;
gui.D_Fq_c = 0;
gui.D_FLFO_c = 0;
gui.D_FADSR_c = 0;
gui.D_Fstages_c = 0;
gui.D_Fvelocity_c = 0;
gui.D_Algo_c = 0;
New ();
New_Bank ();
char *url = argv[1];
char *host = lo_url_get_hostname (url);
char *port = lo_url_get_port (url);
char *path = lo_url_get_path (url);
char *label = argv[3];
char *temp;
pthread_create (&thr1, NULL, thread1, NULL);
gui.ui_win->copy_label (argv[3]);
gui.ui_win->show ();
sprintf (gui.uBankFilename, "%s/Default.goomf", DATADIR);
loadOK = loadbank (gui.uBankFilename);
osc_server = 0;
m_host = lo_address_new (host, port);
osc_configure_path = osc_build_path (path, "/configure");
osc_control_path = osc_build_path (path, "/control");
osc_exiting_path = osc_build_path (path, "/exiting");
osc_hide_path = osc_build_path (path, "/hide");
osc_midi_path = osc_build_path (path, "/midi");
osc_program_path = osc_build_path (path, "/program");
osc_quit_path = osc_build_path (path, "/quit");
osc_show_path = osc_build_path (path, "/show");
osc_update_path = osc_build_path (path, "/update");
osc_server = lo_server_new (NULL, osc_error);
lo_server_add_method (osc_server, osc_configure_path, "ss",
configure_handler, NULL);
lo_server_add_method (osc_server, osc_control_path, "if", control_handler,
NULL);
lo_server_add_method (osc_server, osc_hide_path, "", hide_handler, NULL);
lo_server_add_method (osc_server, osc_program_path, "ii", program_handler,
NULL);
lo_server_add_method (osc_server, osc_quit_path, "", quit_handler, NULL);
lo_server_add_method (osc_server, osc_exiting_path, "", exiting_handler,
NULL);
lo_server_add_method (osc_server, osc_show_path, "", show_handler, NULL);
lo_server_add_method (osc_server, NULL, NULL, debug_handler, NULL);
temp = lo_server_get_url (osc_server);
myurl = osc_build_path (temp, (strlen (path) > 1 ? path + 1 : path));
lo_send (m_host, osc_update_path, "s", myurl);
sleep (2);
gui.d_osc_label->copy_label (myurl);
gui.d_osc_label->redraw ();
if (!loadOK)
Send_laristra ();
lo_fd = lo_server_get_socket_fd (osc_server);
if (lo_fd > 0)
{
do
{
FD_ZERO (&rfds);
FD_SET (lo_fd, &rfds);
retval = select (lo_fd + 1, &rfds, NULL, NULL, NULL);
if (retval == -1)
{
printf ("select() error\n");
exit (1);
}
else if (retval > 0)
{
if (FD_ISSET (0, &rfds))
{
read_stdin ();
}
if (FD_ISSET (lo_fd, &rfds))
{
lo_server_recv_noblock (osc_server, 0);
}
}
}
while (!done);
}
else
{
do
{
FD_ZERO (&rfds);
FD_SET (0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 10000;
retval = select (1, &rfds, NULL, NULL, &tv);
if (retval == -1)
{
printf ("select() error\n");
exit (1);
}
else if (retval > 0 && FD_ISSET (0, &rfds))
{
read_stdin ();
}
lo_server_recv_noblock (osc_server, 0);
}
while (!done);
}
free (host);
free (port);
free (path);
free (osc_configure_path);
free (osc_control_path);
free (osc_exiting_path);
free (osc_hide_path);
free (osc_midi_path);
free (osc_program_path);
free (osc_quit_path);
free (osc_show_path);
free (osc_update_path);
free (myurl);
return (0);
}
int
main (int argc, char **argv)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
cjpeg_source_ptr src_mgr;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "cjpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG compression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Initialize JPEG parameters.
* Much of this may be overridden later.
* In particular, we don't yet know the input file's color space,
* but we need to provide some value for jpeg_set_defaults() to work.
*/
cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
jpeg_set_defaults(&cinfo);
/* Scan command line to find file names.
* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Figure out the input file format, and set up to read it. */
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;
/* Read the input file header to obtain file size & colorspace. */
(*src_mgr->start_input) (&cinfo, src_mgr);
/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);
/* Start compressor */
jpeg_start_compress(&cinfo, TRUE);
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}
/* Finish compression and release memory */
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
