void nprintf(usbdevice* kb, usbprofile* profile, usbmode* mode, const char* format, ...){ if(!kb && !profile) return; if(!profile) profile = &kb->profile; va_list va_args; int fifo; // Write the string to the keyboard's FIFOs (if any) for(int i = 0; i < OUTFIFO_MAX; i++){ va_start(va_args, format); if(kb && (fifo = kb->outfifo[i])){ if(mode) dprintf(fifo, "mode %d ", INDEX_OF(mode, profile->mode) + 1); vdprintf(fifo, format, va_args); } // Write it to the root FIFOs and include the serial number va_start(va_args, format); if((fifo = keyboard[0].outfifo[i])){ dprintf(fifo, "device %s ", profile->serial); if(mode) dprintf(fifo, "mode %d ", INDEX_OF(mode, profile->mode) + 1); vdprintf(fifo, format, va_args); } } }
/*! * @brief Poll a named pipe for data to recv and block when none available. * @param remote Pointer to the remote instance. * @param timeout Amount of time to wait before the poll times out (in milliseconds). * @return Indication of success or failure. */ static DWORD server_pipe_poll(Remote* remote, long timeout) { DWORD bytesAvailable = 0; NamedPipeTransportContext* ctx = (NamedPipeTransportContext*)remote->transport->ctx; lock_acquire(remote->lock); vdprintf("[NP DISPATCH] testing for data on the pipe, making sure there's enough for a packet header"); BOOL ready = PeekNamedPipe(ctx->pipe, NULL, 0, NULL, &bytesAvailable, NULL) && bytesAvailable >= sizeof(PacketHeader); DWORD result = GetLastError(); lock_release(remote->lock); if (ready) { vdprintf("[NP DISPATCH] pipe data found %u bytes", bytesAvailable); result = ERROR_SUCCESS; } else { if (result != ERROR_BROKEN_PIPE) { // simulate a wait so that we don't bash the crap out of the CPU? vdprintf("[NP DISPATCH] pipe data not found, sleeping (error %u)", GetLastError()); Sleep(timeout); result = ERROR_NO_DATA; } } return result; }
void nprintf(usbdevice* kb, int nodenumber, usbmode* mode, const char* format, ...){ if(!kb) return; usbprofile* profile = kb->profile; va_list va_args; int fifo; if(nodenumber >= 0){ // If node number was given, print to that node (if open) if((fifo = kb->outfifo[nodenumber] - 1) != -1){ va_start(va_args, format); if(mode) dprintf(fifo, "mode %d ", INDEX_OF(mode, profile->mode) + 1); vdprintf(fifo, format, va_args); } return; } // Otherwise, print to all nodes for(int i = 0; i < OUTFIFO_MAX; i++){ if((fifo = kb->outfifo[i] - 1) != -1){ va_start(va_args, format); if(mode) dprintf(fifo, "mode %d ", INDEX_OF(mode, profile->mode) + 1); vdprintf(fifo, format, va_args); } } }
static void coutl2(const char *color, const char *f, ...) { va_list ap; if (output_fd == -1) output_fd = open("/dev/tty", O_RDWR); va_start(ap, f); vdprintf(logfile_fd, f, ap); va_end(ap); va_start(ap, f); cout(color); vdprintf(output_fd, f, ap); cout(C_CLEAR); va_end(ap); }
/** * Log a message to a filedescriptor. * @param fd File descritpor where the log will be written to * @param lf Logging priority (equal to syslog) * @param fmt Format string * @param ap Variable parameter list * @param with_errno Flag if errno should be printed too */ void vlog_msgf(int fd, int lf, const char* fmt, va_list ap, int with_errno) { int level = LOG_PRI(lf); char buf[1024]; if (level_ < level) { return; } if (fd > -1) { dprintf(fd, "%s;", flty_[level]); vdprintf(fd, fmt, ap); if (with_errno) { dprintf(fd, " (%s)", strerror(errno)); } dprintf(fd, "\n"); } else { vsnprintf(buf, sizeof(buf), fmt, ap); syslog(level | LOG_DAEMON, "%s", buf); } }
// POSIX calls this dprintf, but LP32 Android had fdprintf instead. extern "C" int fdprintf(int fd, const char* fmt, ...) { va_list ap; va_start(ap, fmt); int rc = vdprintf(fd, fmt, ap); va_end(ap); return rc; }
int http_reply(const char *file, int line, enum http_status code, const char *fmt, ...) { const char *msg = NULL; va_list ap; int a; int b; switch (code) { #define XX(num, name, string) case num: msg = # string; break; HTTP_STATUS_MAP(XX) #undef XX default: return http_reply(file, line, HTTP_STATUS_INTERNAL_SERVER_ERROR, NULL); } fprintf(stderr, " => %d (%s:%d)\n", code, file, line); a = dprintf(STDOUT_FILENO, "HTTP/1.1 %d %s\r\n", code, msg); if (a < 0) return a; va_start(ap, fmt); b = vdprintf(STDOUT_FILENO, fmt ? fmt : "Content-Length: 0\r\n\r\n", ap); va_end(ap); return b < 0 ? b : a + b; }
i64 _debug_out_( bool info, ch_dbg_mode_e mode, i64 line_num, const char* filename, const char* function, const char* format, ... ) //Intentionally using char* here as these are passed in as constants { va_list args; va_start(args,format); char* fn = (char*)filename; char* mode_str = NULL; switch(mode){ case DBGMODE_HEX: mode_str = "Hexdump"; break; case DBGMODE_FAT: mode_str = "Fatal "; break; case DBGMODE_ERR: mode_str = "Error "; break; case DBGMODE_DBG: mode_str = "Debug "; break; case DBGMODE_WARN: mode_str = "Warning"; break; } if(info) dprintf(OUTPUT_TO,"[%s - %s:%i:%s()] ", mode_str, basename(fn), (int)line_num, function); i64 result = vdprintf(OUTPUT_TO,format,args); va_end(args); if(mode == DBGMODE_FAT){ exit(-1); } return result; }
static void display_put(const char *fmt, ...) { va_list args; va_start(args, fmt); vdprintf(logFd(), fmt, args); va_end(args); }
int send_frame(int fd, char *format, ...) { int r; #ifdef VERBOSE_COMMS { va_list debug_args; va_start(debug_args, format); if(printf("tx:[") == -1) { r = -1; } else if((r = vprintf(format, debug_args)) == -1) { r = -1; } else if(printf("]\r\n") == -1) { r = -1; } va_end(debug_args); } #endif va_list args; va_start(args, format); if(dprintf(fd, "[") == -1) { r = -1; } else if((r = vdprintf(fd, format, args)) == -1) { r = -1; } else if(dprintf(fd, "]\r") == -1) { r = -1; } va_end(args); return r; }
void logLog(enum llevel_t ll, const char *fn, int ln, bool perr, const char *fmt, ...) { if (ll == DEBUG && !log_verbose) { return; } char strerr[512]; if (perr == true) { snprintf(strerr, sizeof(strerr), "%s", strerror(errno)); } struct ll_t { char *descr; char *prefix; bool print_funcline; }; struct ll_t logLevels[] = { {"HR", "\033[0m", false}, {"HB", "\033[1m", false}, {"D", "\033[0;4m", true}, {"I", "\033[1m", true}, {"W", "\033[0;33m", true}, {"E", "\033[1;31m", true}, {"F", "\033[7;35m", true}, }; time_t ltstamp = time(NULL); struct tm utctime; localtime_r(<stamp, &utctime); char timestr[32]; if (strftime(timestr, sizeof(timestr) - 1, "%FT%T%z", &utctime) == 0) { timestr[0] = '\0'; } /* Start printing logs */ if (log_fd_isatty) { dprintf(log_fd, "%s", logLevels[ll].prefix); } if (logLevels[ll].print_funcline) { dprintf(log_fd, "[%s][%s][%ld] %s():%d ", timestr, logLevels[ll].descr, syscall(__NR_getpid), fn, ln); } va_list args; va_start(args, fmt); vdprintf(log_fd, fmt, args); va_end(args); if (perr == true) { dprintf(log_fd, ": %s", strerr); } if (log_fd_isatty) { dprintf(log_fd, "\033[0m"); } dprintf(log_fd, "\n"); /* End printing logs */ if (ll == FATAL) { exit(1); } }
int dprintf(int fd, const char *fmt, ...) { va_list args; va_start(args, fmt); return vdprintf(fd, fmt, args); va_end(args); }
/* write to temp file.. */ static void fdprintf(int fd, const char *ctl, ...) { va_list va; va_start(va, ctl); vdprintf(fd, ctl, va); va_end(va); }
int dprintf(int fd, const char *fmt, ...) { int ret; va_list ap; va_start(ap, fmt); ret = vdprintf(fd, fmt, ap); va_end(ap); return ret; }
ocschedStatus ocsched_printf(ocschedProcessContext * ctx,char * fmtstr,...) { va_list ap; va_start(ap,fmtstr); vdprintf(ctx->comm.pipe_out,fmtstr,ap); va_end(ap); return OCSCHED_SUCCESS; }
int ly_print(struct lyout *out, const char *format, ...) { int count = 0; char *msg = NULL, *aux; va_list ap; #ifndef HAVE_VDPRINTF FILE *stream; #endif va_start(ap, format); switch (out->type) { case LYOUT_FD: #ifdef HAVE_VDPRINTF count = vdprintf(out->method.fd, format, ap); #else stream = fdopen(dup(out->method.fd), "a+"); if (stream) { count = vfprintf(stream, format, ap); fclose(stream); } #endif break; case LYOUT_STREAM: count = vfprintf(out->method.f, format, ap); break; case LYOUT_MEMORY: count = vasprintf(&msg, format, ap); if (out->method.mem.len + count + 1 > out->method.mem.size) { aux = ly_realloc(out->method.mem.buf, out->method.mem.len + count + 1); if (!aux) { out->method.mem.buf = NULL; out->method.mem.len = 0; out->method.mem.size = 0; LOGMEM(NULL); va_end(ap); return -1; } out->method.mem.buf = aux; out->method.mem.size = out->method.mem.len + count + 1; } memcpy(&out->method.mem.buf[out->method.mem.len], msg, count); out->method.mem.len += count; out->method.mem.buf[out->method.mem.len] = '\0'; free(msg); break; case LYOUT_CALLBACK: count = vasprintf(&msg, format, ap); count = out->method.clb.f(out->method.clb.arg, msg, count); free(msg); break; } va_end(ap); return count; }
/* ========================================================================== * * Write line to stream * ========================================================================== */ int say (const saymode_t mode, const saylevel_t level, const char * const str, ...) { va_list arg; int out = 0; int priority = 0; ASSERT_RETURN (str, "str is NULL.\n", -1) /* Set how to print */ switch (level) { case MSG_E: { out = STDERR_FILENO; priority = LOG_ERR; break; } case MSG_W: { out = STDOUT_FILENO; priority = LOG_WARNING; break; } case MSG_I: { out = STDOUT_FILENO; priority = LOG_INFO; break; } default: { return -1; } } va_start (arg, str); /* Write line */ switch (mode) { case MODE_FILE: vsyslog (priority, str, arg); break; case MODE_OUT: vdprintf (out, str, arg); break; default: return -1; } va_end (arg); return 1; }
/*! * @brief Prepare a wininet request with the given context. * @param ctx Pointer to the HTTP transport context to prepare the request from. * @param isGet Indication of whether this request is a GET request, otherwise POST is used. * @param direction String representing the direction of the communications (for debug). * @return An Internet request handle. */ static HINTERNET get_request_wininet(HttpTransportContext *ctx, BOOL isGet, const char *direction) { HINTERNET hReq = NULL; DWORD flags = INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_AUTO_REDIRECT | INTERNET_FLAG_NO_UI; if (ctx->ssl) { flags |= INTERNET_FLAG_SECURE | INTERNET_FLAG_IGNORE_CERT_CN_INVALID | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID; dprintf("[%s] Setting secure request flag..", direction); } do { vdprintf("[%s] opening request on connection %x to %S", direction, ctx->connection, ctx->uri); hReq = HttpOpenRequestW(ctx->connection, isGet ? L"GET" : L"POST", ctx->uri, NULL, NULL, NULL, flags, 0); if (hReq == NULL) { dprintf("[%s] Failed HttpOpenRequestW: %d", direction, GetLastError()); SetLastError(ERROR_NOT_FOUND); break; } if (ctx->ssl) { DWORD secureFlags = SECURITY_FLAG_IGNORE_CERT_CN_INVALID | SECURITY_FLAG_IGNORE_CERT_DATE_INVALID | SECURITY_FLAG_IGNORE_WRONG_USAGE | SECURITY_FLAG_IGNORE_UNKNOWN_CA | SECURITY_FLAG_IGNORE_REVOCATION; dprintf("[%s] Setting secure option flags", direction); if (!InternetSetOptionW(hReq, INTERNET_OPTION_SECURITY_FLAGS, &secureFlags, sizeof(secureFlags))) { dprintf("[%s] Failed InternetSetOptionW: %d", direction, GetLastError()); SetLastError(ERROR_NOT_FOUND); break; } } return hReq; } while (0); if (hReq != NULL) { InternetCloseHandle(hReq); } return NULL; }
static int log_stderr(const char *format, ...) { int result; va_list args; va_start(args, format); result = vdprintf(STDERR_FILENO, format, args); va_end(args); return result; }
void log_print(int priority, const char *format, ...) { if (priority < log_priority || log_fd < 0) return; va_list va_arg; va_start(va_arg, format); vdprintf(log_fd, format, va_arg); va_end(va_arg); }
/*! * @brief Wrapper around WinINET-specific request response validation. * @param hReq HTTP request handle. * @param ctx The HTTP transport context. * @return An indication of the result of getting a response. */ static DWORD validate_response_wininet(HANDLE hReq, HttpTransportContext* ctx) { DWORD statusCode; DWORD statusCodeSize = sizeof(statusCode); vdprintf("[PACKET RECEIVE WININET] Getting the result code..."); if (HttpQueryInfoW(hReq, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &statusCode, &statusCodeSize, 0)) { vdprintf("[PACKET RECEIVE WININET] Returned status code is %d", statusCode); // did the request succeed? if (statusCode != 200) { // bomb out return ERROR_BAD_CONFIGURATION; } } return ERROR_SUCCESS; }
void logFormat(char* text,...) { int fd = open(LOGFILE, O_CREAT| O_WRONLY | O_APPEND,0644); if (fd>=0) { va_list arglist; va_start(arglist, text); vdprintf(fd,text, arglist); close(fd); } }
int printf(const char* fmt, ...) { va_list args; va_start(args, fmt); int ret = vdprintf(STDOUT_FILENO, fmt, args); va_end(args); return ret; }
/* From glibc */ int dprintf(int d, const char *format, ...) { va_list arg; int done; va_start (arg, format); done = vdprintf (d, format, arg); va_end (arg); return done; }
void print_log(char *str, ...) { va_list ap; if (VERBOSE) { va_start(ap, str); vdprintf(2, str, ap); va_end(ap); } }
void nrprintf(const char* format, ...){ va_list va_args; char line = '\n'; int fifo; for(int i = 0; i < OUTFIFO_MAX; i++){ va_start(va_args, format); if((fifo = keyboard[0].outfifo[i])){ vdprintf(fifo, format, va_args); } } }
static void cout(const char *f, ...) { va_list ap; if (output_fd == -1) output_fd = open("/dev/tty", O_RDWR); va_start(ap, f); vdprintf(output_fd, f, ap); va_end(ap); }
static int conn_send(const conn_t *conn, const char *fmt, ...) { va_list ap; int r; va_start(ap, fmt); r = vdprintf(conn->sock, fmt, ap); va_end(ap); return r; }
int dprintf(int fd, FAR const IPTR char *fmt, ...) { va_list ap; int ret; va_start(ap, fmt); ret = vdprintf(fd, fmt, ap); va_end(ap); return ret; }
void nrprintf(int nodenumber, const char* format, ...){ if(nodenumber >= OUTFIFO_MAX) return; va_list va_args; int fifo; if(nodenumber >= 0){ // If node number was given, print to that node (if open) if((fifo = keyboard[0].outfifo[nodenumber])){ va_start(va_args, format); vdprintf(fifo, format, va_args); } return; } // Otherwise, print to all nodes for(int i = 0; i < OUTFIFO_MAX; i++){ if((fifo = keyboard[0].outfifo[i])){ va_start(va_args, format); vdprintf(fifo, format, va_args); } } }