Archives
/
echoping
mirror of https://framagit.org/bortzmeyer/echoping
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

New indent parameters, many spurious changes

Browse Source
MAINT_6_0
Stephane Bortzmeyer 17 years ago
parent 3754822e91
commit b60d7eb6d2
17 changed files with 1406 additions and 1392 deletions
Show Stats Download Patch File Download Diff File

141
SRC/contrib/adamsnames/domquery.c
Unescape Escape View File

@ -19,96 +19,93 @@
#include "common.h"
void
domquery_usage (char *msg)
domquery_usage(char *msg)
{
fprintf (stderr, "%s\n", msg);
poptPrintUsage (poptcon, stderr, 0);
err_quit(" domain");
fprintf(stderr, "%s\n", msg);
poptPrintUsage(poptcon, stderr, 0);
err_quit(" domain");
}
char *
init (int argc, char **argv)
char *
init(int argc, char **argv)
{
int value;
xmlrpc_value *result;
xmlrpc_bool free, read_contacts;
xmlrpc_int32 reason;
char *msg, *hostname;
struct poptOption options[] = {
{"read-contacts", 'c', POPT_ARG_NONE, &read_contacts, 0,
"Read also the contacts of the domain [NOT IMPLEMENTED]",
""},
POPT_AUTOHELP POPT_TABLEEND
};
poptcon = poptGetContext (NULL, argc,
argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt (poptcon)) > 0)
{
if (value < -1)
{
sprintf (msg, "%s: %s",
poptBadOption (poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror (value));
domquery_usage (msg);
}
}
hostname = (char *) poptGetArg (poptcon); /* Not used */
domain = (char *) poptGetArg (poptcon);
if (domain == NULL || !strcmp(domain, ""))
domquery_usage ("Mandatory request missing");
return NULL;
int value;
xmlrpc_value *result;
xmlrpc_bool free, read_contacts;
xmlrpc_int32 reason;
char *msg, *hostname;
struct poptOption options[] = {
{"read-contacts", 'c', POPT_ARG_NONE, &read_contacts, 0,
"Read also the contacts of the domain [NOT IMPLEMENTED]",
""},
POPT_AUTOHELP POPT_TABLEEND
};
poptcon = poptGetContext(NULL, argc, argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt(poptcon)) > 0) {
if (value < -1) {
sprintf(msg, "%s: %s",
poptBadOption(poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror(value));
domquery_usage(msg);
}
}
hostname = (char *) poptGetArg(poptcon); /* Not used */
domain = (char *) poptGetArg(poptcon);
if (domain == NULL || !strcmp(domain, ""))
domquery_usage("Mandatory request missing");
return NULL;
}
void
start_raw() {
start_raw()
{
/* Start up our XML-RPC client library. */
xmlrpc_client_init (XMLRPC_CLIENT_NO_FLAGS, CLIENT_NAME, CLIENT_VERSION);
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, CLIENT_NAME, CLIENT_VERSION);
/* Initialize our error-handling environment. */
xmlrpc_env_init (&env);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
printf ("env initialized\n");
printf("env initialized\n");
}
int
execute ()
execute()
{
xmlrpc_value *result;
xmlrpc_value *domain_h;
xmlrpc_int32 found;
xmlrpc_value *error;
/* char *dst;
dst = HTAnchor_findAddress(ENDPOINT); */
printf ("Ready to call\n");
/* Call the server */
result = xmlrpc_client_call (&env, ENDPOINT, "domquery", "(s)", domain);
die_if_fault_occurred (&env);
printf ("Call done, now parsing\n");
xmlrpc_parse_value (&env, result, "{s:i,*}", "found", &found);
die_if_fault_occurred (&env);
if (found)
{
printf ("%s is there\n", domain);
xmlrpc_parse_value (&env, result, "{s:S,i,s:A,*}", "domain", &domain_h, "found", &found, "error", &error);
die_if_fault_occurred (&env);
}
/* Dispose of our result value. */
xmlrpc_DECREF (result);
return 0;
xmlrpc_value *result;
xmlrpc_value *domain_h;
xmlrpc_int32 found;
xmlrpc_value *error;
/* char *dst; dst = HTAnchor_findAddress(ENDPOINT); */
printf("Ready to call\n");
/* Call the server */
result = xmlrpc_client_call(&env, ENDPOINT, "domquery", "(s)", domain);
die_if_fault_occurred(&env);
printf("Call done, now parsing\n");
xmlrpc_parse_value(&env, result, "{s:i,*}", "found", &found);
die_if_fault_occurred(&env);
if (found) {
printf("%s is there\n", domain);
xmlrpc_parse_value(&env, result, "{s:S,i,s:A,*}", "domain",
&domain_h, "found", &found, "error", &error);
die_if_fault_occurred(&env);
}
/* Dispose of our result value. */
xmlrpc_DECREF(result);
return 0;
}
void
terminate ()
terminate()
{
/* Clean up our error-handling environment. */
xmlrpc_env_clean (&env);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup ();
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
}
}

105
SRC/contrib/adamsnames/test-domquery.c
Unescape Escape View File

@ -14,72 +14,67 @@
#define ENDPOINT "http://www.adamsnames.tc/api/xmlrpc"
void
die_if_fault_occurred (xmlrpc_env * env)
die_if_fault_occurred(xmlrpc_env * env)
{
if (env->fault_occurred)
{
fprintf (stderr, "XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
exit (1);
}
if (env->fault_occurred) {
fprintf(stderr, "XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
exit(1);
}
}
int
main (int argc, char **argv)
main(int argc, char **argv)
{
int value;
xmlrpc_value *result;
xmlrpc_bool free, read_contacts;
xmlrpc_int32 reason;
xmlrpc_value *domain_h;
xmlrpc_int32 found;
xmlrpc_value *error;
xmlrpc_env env;
char *domain;
char *date, *holder;
int value;
xmlrpc_value *result;
xmlrpc_bool free, read_contacts;
xmlrpc_int32 reason;
xmlrpc_value *domain_h;
xmlrpc_int32 found;
xmlrpc_value *error;
xmlrpc_env env;
char *domain;
char *date, *holder;
if (argc != 2)
{
fprintf (stderr, "Usage: %s domain\n", argv[0]);
exit (1);
}
if (argc != 2) {
fprintf(stderr, "Usage: %s domain\n", argv[0]);
exit(1);
}
domain = argv[1];
domain = argv[1];
/* Start up our XML-RPC client library. */
xmlrpc_client_init (XMLRPC_CLIENT_NO_FLAGS, CLIENT_NAME, CLIENT_VERSION);
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, CLIENT_NAME, CLIENT_VERSION);
/* Initialize our error-handling environment. */
xmlrpc_env_init (&env);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Call the server */
result = xmlrpc_client_call (&env, ENDPOINT, "domquery", "(s)", domain);
die_if_fault_occurred (&env);
/* Call the server */
result = xmlrpc_client_call(&env, ENDPOINT, "domquery", "(s)", domain);
die_if_fault_occurred(&env);
xmlrpc_parse_value (&env, result, "{s:i,*}", "found", &found);
die_if_fault_occurred (&env);
if (found)
{
printf ("%s is there\n", domain);
xmlrpc_parse_value (&env, result, "{s:S,s:i,s:A,*}", "domain",
&domain_h, "found", &found, "error", &error);
die_if_fault_occurred (&env);
/* printf ("Type of domain: %d\n", xmlrpc_value_type(domain_h)); */
xmlrpc_parse_value (&env, domain_h, "{s:s,s:s,*}", "registered", &date,
"org", &holder);
die_if_fault_occurred (&env);
printf ("Registered on %s by %s\n", date, holder);
}
else
{
printf ("Unknown domain %s\n", domain);
}
/* Dispose of our result value. */
xmlrpc_DECREF (result);
/* Clean up our error-handling environment. */
xmlrpc_env_clean (&env);
xmlrpc_parse_value(&env, result, "{s:i,*}", "found", &found);
die_if_fault_occurred(&env);
if (found) {
printf("%s is there\n", domain);
xmlrpc_parse_value(&env, result, "{s:S,s:i,s:A,*}", "domain",
&domain_h, "found", &found, "error", &error);
die_if_fault_occurred(&env);
/* printf ("Type of domain: %d\n", xmlrpc_value_type(domain_h)); */
xmlrpc_parse_value(&env, domain_h, "{s:s,s:s,*}", "registered",
&date, "org", &holder);
die_if_fault_occurred(&env);
printf("Registered on %s by %s\n", date, holder);
} else {
printf("Unknown domain %s\n", domain);
}
/* Dispose of our result value. */
xmlrpc_DECREF(result);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup ();
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
}

12
SRC/contrib/adamsnames/util.c
Unescape Escape View File

@ -4,12 +4,10 @@
#include <xmlrpc_client.h>
void
die_if_fault_occurred (xmlrpc_env * env)
die_if_fault_occurred(xmlrpc_env * env)
{
if (env->fault_occurred)
{
err_quit("XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
}
if (env->fault_occurred) {
err_quit("XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
}
}

55
SRC/contrib/daytime/daytime.c
Unescape Escape View File

@ -8,47 +8,48 @@
#include "../../echoping.h"
struct addrinfo daytime_server;
int sockfd;
int sockfd;
echoping_options options;
char *
init (const int argc, const char **argv, echoping_options global_options)
char *
init(const int argc, const char **argv, echoping_options global_options)
{
if (global_options.udp)
err_quit ("Sorry, UDP is not yet compatible with this daytime plugin");
options = global_options;
return "daytime";
if (global_options.udp)
err_quit
("Sorry, UDP is not yet compatible with this daytime plugin");
options = global_options;
return "daytime";
}
void
start (struct addrinfo *res)
start(struct addrinfo *res)
{
daytime_server = *res;
daytime_server = *res;
}
int
execute ()
execute()
{
int nr;
FILE *file;
int nr;
FILE *file;
#define MAX 256
char recvline[MAX];
if ((sockfd =
socket (daytime_server.ai_family, daytime_server.ai_socktype,
daytime_server.ai_protocol)) < 0)
err_sys ("Can't open socket");
if (connect (sockfd, daytime_server.ai_addr, daytime_server.ai_addrlen) < 0)
err_sys ("Can't connect to server");
if ((file = fdopen (sockfd, "r")) == NULL)
err_sys ("Cannot fdopen");
nr = readline (file, recvline, MAX, 1);
if (options.verbose)
printf ("%s", recvline);
close (sockfd);
return 1;
char recvline[MAX];
if ((sockfd =
socket(daytime_server.ai_family, daytime_server.ai_socktype,
daytime_server.ai_protocol)) < 0)
err_sys("Can't open socket");
if (connect(sockfd, daytime_server.ai_addr, daytime_server.ai_addrlen) < 0)
err_sys("Can't connect to server");
if ((file = fdopen(sockfd, "r")) == NULL)
err_sys("Cannot fdopen");
nr = readline(file, recvline, MAX, 1);
if (options.verbose)
printf("%s", recvline);
close(sockfd);
return 1;
}
void
terminate ()
terminate()
{
}

523
SRC/echoping.c
View File

File diff suppressed because it is too large Load Diff

81
SRC/error.c
Unescape Escape View File

@ -5,9 +5,9 @@
/* Most of error-handling routines stolen from Stevens' books */
void
my_perror ()
my_perror()
{
fprintf (stderr, " %s\n", sys_err_str ());
fprintf(stderr, " %s\n", sys_err_str());
}
/*
@ -20,20 +20,20 @@ my_perror ()
/* VARARGS1 */
void
err_ret (char *str, ...)
err_ret(char *str, ...)
{
va_list args;
va_list args;
va_start (args, str);
vfprintf (stderr, str, args);
va_end (args);
va_start(args, str);
vfprintf(stderr, str, args);
va_end(args);
my_perror ();
my_perror();
fflush (stdout);
fflush (stderr);
fflush(stdout);
fflush(stderr);
return;
return;
}
/*
@ -47,16 +47,16 @@ err_ret (char *str, ...)
/* VARARGS1 */
void
err_quit (char *str, ...)
err_quit(char *str, ...)
{
va_list args;
va_list args;
va_start (args, str);
vfprintf (stderr, str, args);
fputc ('\n', stderr);
va_end (args);
va_start(args, str);
vfprintf(stderr, str, args);
fputc('\n', stderr);
va_end(args);
exit (1);
exit(1);
}
/*
@ -71,25 +71,25 @@ err_quit (char *str, ...)
/* VARARGS1 */
void
err_sys (char *str, ...)
err_sys(char *str, ...)
{
va_list args;
va_list args;
va_start (args, str);
vfprintf (stderr, str, args);
va_end (args);
va_start(args, str);
vfprintf(stderr, str, args);
va_end(args);
my_perror ();
my_perror();
exit (1);
exit(1);
}
void
usage (poptContext context)
usage(poptContext context)
{
poptPrintUsage (context, stderr, 0);
fprintf (stderr, " hostname [plugin-options...]\n");
exit (1);
poptPrintUsage(context, stderr, 0);
fprintf(stderr, " hostname [plugin-options...]\n");
exit(1);
}
/*
@ -102,18 +102,15 @@ usage (poptContext context)
* decimal value of errno to the other system.
*/
char *
sys_err_str ()
char *
sys_err_str()
{
static char msgstr[200];
if (errno != 0)
{
sprintf (msgstr, "(%s)", strerror (errno));
}
else
{
msgstr[0] = '\0';
}
return (msgstr);
static char msgstr[200];
if (errno != 0) {
sprintf(msgstr, "(%s)", strerror(errno));
} else {
msgstr[0] = '\0';
}
return (msgstr);
}

43
SRC/http.c
Unescape Escape View File

@ -18,21 +18,30 @@ make_http_sendline(char *url, char *host, int port, int nocache)
char *cache_directive = "";
#ifdef HTTP10
if (nocache)
cache_directive = "Pragma: no-cache\r\n"; /* RFC 1945, "Hypertext
* Transfer Protocol --
* HTTP/1.0" */
cache_directive = "Pragma: no-cache\r\n"; /* RFC 1945,
* "Hypertext
* Transfer Protocol
* -- HTTP/1.0" */
sprintf(sendline,
"GET %s HTTP/1.0\r\nUser-Agent: Echoping/%s\r\n%s\r\n",
url, VERSION, cache_directive);
#else
if (nocache) {
if (nocache == 1)
cache_directive = "Cache-control: max-age=0\r\n"; /* Simply force a
* recheck with the
* server */
cache_directive = "Cache-control: max-age=0\r\n"; /* Simply
* force
* a
* recheck
* with
* the
* server
*/
else
cache_directive = "Cache-control: no-cache\r\n"; /* RFC 2616 "Hypertext
* Transfer Protocol --
cache_directive = "Cache-control: no-cache\r\n"; /* RFC
* 2616
* "Hypertext
* Transfer
* Protocol --
* HTTP/1.1" */
}
strcpy(hostname, HTParse(url, "", PARSE_HOST));
@ -75,15 +84,16 @@ read_from_server(CHANNEL fs, short ssl, boolean accept_redirects)
{
nr = TLS_readline(fs.tls, big_recvline, MAXTOREAD, TRUE);
if (nr == -1) {
err_ret("TLS_readline error: %s", gnutls_strerror(nr));
err_ret("TLS_readline error: %s",
gnutls_strerror(nr));
}
}
#endif
/*
/*
* printf ("DEBUG: reading \"%s\"\n (%d chars)\n",
* big_recvline, nr);
*/
/*
/*
* HTTP replies should be separated by CR-LF. Unfortunately,
* some servers send only CR :-(
*/
@ -94,14 +104,15 @@ read_from_server(CHANNEL fs, short ssl, boolean accept_redirects)
/* SourceForge bug #109385 */
/* err_sys ("Error reading HTTP header"); */
return -1;
/*
/*
* if ((int) big_recvline[nr-1] == 10) nr--;
*/
if (first_line) {
reply_code = big_recvline[9]; /* 9 because "HTTP/1.x
* 200..." */
if (reply_code != '2' && !(reply_code == '3' && accept_redirects))
/*
if (reply_code != '2'
&& !(reply_code == '3' && accept_redirects))
/*
* Status codes beginning with 3 are not
* errors See bug #850674 and RFC 2616,
* section 10.3
@ -122,13 +133,13 @@ read_from_server(CHANNEL fs, short ssl, boolean accept_redirects)
else
nr = TLS_readline(fs.tls, big_recvline, MAXTOREAD, FALSE);
#endif
/*
/*
* printf ("DEBUG: reading body \"%s\"\n (%d chars)\n", big_recvline,
* nr);
*/
if ((nr < 2) && (timeout_flag)) /* Probably a timeout */
return -1;
if (nr < 2) /* Hmm, if the body is empty, we'll get a
if (nr < 2) /* Hmm, if the body is empty, we'll get a *
* meaningless error message */
err_sys("Error reading HTTP body");
total = total + nr;

159
SRC/icp.c
Unescape Escape View File

@ -11,97 +11,96 @@
#ifdef ICP
void *
make_icp_sendline (url, shost, opcode, length)
const char *url;
u_num32 *shost;
icp_opcode opcode;
int *length;
void *
make_icp_sendline(url, shost, opcode, length)
const char *url;
u_num32 *shost;
icp_opcode opcode;
int *length;
{
icp_common_t *headerp = NULL;
char *buf = NULL;
char *urloffset = NULL;
u_num32 flags = ICP_FLAG_SRC_RTT;
u_num32 pad = 0;
u_num32 reqnum = 4711;
unsigned short buf_len;
icp_common_t *headerp = NULL;
char *buf = NULL;
char *urloffset = NULL;
u_num32 flags = ICP_FLAG_SRC_RTT;
u_num32 pad = 0;
u_num32 reqnum = 4711;
unsigned short buf_len;
buf_len = sizeof (icp_common_t) + strlen (url) + 1;
if (opcode == ICP_OP_QUERY)
buf_len += sizeof (u_num32);
buf = calloc (buf_len, 1);
headerp = (icp_common_t *) buf;
headerp->opcode = opcode;
headerp->version = ICP_VERSION_CURRENT;
headerp->length = htons (buf_len);
headerp->reqnum = htonl (reqnum);
headerp->flags = htonl (flags);
headerp->pad = pad;
if (shost)
headerp->shostid = htonl (*shost);
/* urloffset = (char *) ((int) buf + sizeof(icp_common_t)); */
urloffset = (char *) (buf + sizeof (icp_common_t));
if (opcode == ICP_OP_QUERY)
urloffset += sizeof (u_num32);
memcpy (urloffset, url, strlen (url));
*length = buf_len;
return buf;
buf_len = sizeof(icp_common_t) + strlen(url) + 1;
if (opcode == ICP_OP_QUERY)
buf_len += sizeof(u_num32);
buf = calloc(buf_len, 1);
headerp = (icp_common_t *) buf;
headerp->opcode = opcode;
headerp->version = ICP_VERSION_CURRENT;
headerp->length = htons(buf_len);
headerp->reqnum = htonl(reqnum);
headerp->flags = htonl(flags);
headerp->pad = pad;
if (shost)
headerp->shostid = htonl(*shost);
/* urloffset = (char *) ((int) buf + sizeof(icp_common_t)); */
urloffset = (char *) (buf + sizeof(icp_common_t));
if (opcode == ICP_OP_QUERY)
urloffset += sizeof(u_num32);
memcpy(urloffset, url, strlen(url));
*length = buf_len;
return buf;
}
int
recv_icp (sockfd, buf, retcode)
int sockfd;
char *buf;
char *retcode;
recv_icp(sockfd, buf, retcode)
int sockfd;
char *buf;
char *retcode;
{ /*
{ /*
* based on draft-wessels-icp-v2-02.txt
*/
icp_common_t *headerp = (icp_common_t *) buf;
int nr, length;
unsigned char opcode;
static char *icp_op_code[] = {
/* 0 */ "ICP_OP_INVALID",
/* 1 */ "ICP_OP_QUERY",
/* 2 */ "ICP_OP_HIT",
/* 3 */ "ICP_OP_MISS",
/* 4 */ "ICP_OP_ERR",
/* 5 */ "",
/* 6 */ "",
/* 7 */ "",
/* 8 */ "",
/* 9 */ "",
/* 10 */ "ICP_OP_SECHO",
/* 11 */ "ICP_OP_DECHO",
/* 12 */ "",
/* 13 */ "",
/* 14 */ "",
/* 15 */ "",
/* 16 */ "",
/* 17 */ "",
/* 18 */ "",
/* 19 */ "",
/* 20 */ "",
/* 21 */ "ICP_OP_MISS_NOFETCH",
/* 22 */ "ICP_OP_DENIED",
/* 23 */ "ICP_OP_HIT_OBJ"
};
icp_common_t *headerp = (icp_common_t *) buf;
int nr, length;
unsigned char opcode;
static char *icp_op_code[] = {
/* 0 */ "ICP_OP_INVALID",
/* 1 */ "ICP_OP_QUERY",
/* 2 */ "ICP_OP_HIT",
/* 3 */ "ICP_OP_MISS",
/* 4 */ "ICP_OP_ERR",
/* 5 */ "",
/* 6 */ "",
/* 7 */ "",
/* 8 */ "",
/* 9 */ "",
/* 10 */ "ICP_OP_SECHO",
/* 11 */ "ICP_OP_DECHO",
/* 12 */ "",
/* 13 */ "",
/* 14 */ "",
/* 15 */ "",
/* 16 */ "",
/* 17 */ "",
/* 18 */ "",
/* 19 */ "",
/* 20 */ "",
/* 21 */ "ICP_OP_MISS_NOFETCH",
/* 22 */ "ICP_OP_DENIED",
/* 23 */ "ICP_OP_HIT_OBJ"
};
nr = recvfrom (sockfd, buf, DEFLINE, 0, (struct sockaddr *) 0, (int *) 0);
if (nr < 0)
{
if (timeout_flag)
err_quit ("Timeout while reading");
else
err_sys ("No reply from ICP proxy server");
}
opcode = headerp->opcode;
length = ntohs (headerp->length);
sprintf (retcode, "ICP reply: \42%s\42", icp_op_code[opcode]);
return length;
nr = recvfrom(sockfd, buf, DEFLINE, 0, (struct sockaddr *) 0, (int *) 0);
if (nr < 0) {
if (timeout_flag)
err_quit("Timeout while reading");
else
err_sys("No reply from ICP proxy server");
}
opcode = headerp->opcode;
length = ntohs(headerp->length);
sprintf(retcode, "ICP reply: \42%s\42", icp_op_code[opcode]);
return length;
}
#endif /* ICP */
#endif /* ICP */

323
SRC/plugins/dns/dns.c
Unescape Escape View File

@ -12,12 +12,12 @@
#include <resolv.h>
struct addrinfo name_server;
poptContext dns_poptcon;
char *request;
int type;
char *type_name = NULL;
boolean use_tcp = FALSE;
boolean no_recurse = FALSE;
poptContext dns_poptcon;
char *request;
int type;
char *type_name = NULL;
boolean use_tcp = FALSE;
boolean no_recurse = FALSE;
/* nsError stolen from Liu & Albitz check_soa (in their book "DNS and BIND") */
@ -34,30 +34,29 @@ boolean no_recurse = FALSE;
* strings. *
****************************************************************/
int
nsError (error, domain)
int error;
char *domain;
nsError(error, domain)
int error;
char *domain;
{
switch (error)
{
case HOST_NOT_FOUND:
err_ret ("Unknown domain: %s\n", domain);
return -1;
case NO_DATA:
err_ret ("No records of type %s for %s in the Answer section\n",
to_upper (type_name), domain);
return -1;
case TRY_AGAIN:
err_ret ("No response for query\n");
return -2;
default:
err_ret ("Unexpected error\n");
return -1;
}
switch (error) {
case HOST_NOT_FOUND:
err_ret("Unknown domain: %s\n", domain);
return -1;
case NO_DATA:
err_ret("No records of type %s for %s in the Answer section\n",
to_upper(type_name), domain);
return -1;
case TRY_AGAIN:
err_ret("No response for query\n");
return -2;
default:
err_ret("Unexpected error\n");
return -1;
}
}
void
dns_usage (const char *msg)
dns_usage(const char *msg)
{
if (msg) {
fprintf(stderr, "Error: %s\n", msg);
@ -67,166 +66,152 @@ dns_usage (const char *msg)
exit(1);
}
char *
init (const int argc, const char **argv)
char *
init(const int argc, const char **argv)
{
int value;
char *hostname;
char *msg = malloc (256);
char *upper_type_name = NULL;
/* popt variables */
struct poptOption options[] = {
{"type", 't', POPT_ARG_STRING, &type_name, 0,
"Type of resources queried (A, MX, SOA, etc)",
"type"},
{"tcp", NULL, POPT_ARG_NONE, &use_tcp, 0,
"Use TCP for the request (virtual circuit)",
"tcp"},
{"no-recurse", NULL, POPT_ARG_NONE, &no_recurse, 0,
"Do not ask recursion",
"no-recurse"},
POPT_AUTOHELP POPT_TABLEEND
};
dns_poptcon = poptGetContext (NULL, argc,
argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt (dns_poptcon)) > 0)
{
}
if (value < -1)
{
sprintf (msg, "%s: %s",
poptBadOption (dns_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror (value));
dns_usage (msg);
}
hostname = (char *) poptGetArg (dns_poptcon); /* Not used */
request = (char *) poptGetArg (dns_poptcon);
if (request == NULL)
dns_usage ("Mandatory request missing");
if ((type_name == NULL) || !strcmp (type_name, ""))
{
type = T_A;
type_name = "A";
}
else
{
upper_type_name = (char *) to_upper (type_name);
/*
* TODO: a better algorithm. Use dns_rdatatype_fromtext in
* BIND ?
*/
if (!strcmp (upper_type_name, "A"))
type = T_A;
else if (!strcmp (upper_type_name, "AAAA"))
type = T_AAAA;
else if (!strcmp (upper_type_name, "NS"))
type = T_NS;
else if (!strcmp (upper_type_name, "SOA"))
type = T_SOA;
else if (!strcmp (upper_type_name, "MX"))
type = T_MX;
else if (!strcmp (upper_type_name, "SRV"))
type = T_SRV;
else if (!strcmp (upper_type_name, "CNAME"))
type = T_CNAME;
else if (!strcmp (upper_type_name, "PTR"))
type = T_PTR;
else if (!strcmp (upper_type_name, "TXT"))
type = T_TXT;
else if (!strcmp (upper_type_name, "ANY"))
type = T_ANY;
else
dns_usage ("Unknown type");
}
return "domain";
int value;
char *hostname;
char *msg = malloc(256);
char *upper_type_name = NULL;
/* popt variables */
struct poptOption options[] = {
{"type", 't', POPT_ARG_STRING, &type_name, 0,
"Type of resources queried (A, MX, SOA, etc)",
"type"},
{"tcp", NULL, POPT_ARG_NONE, &use_tcp, 0,
"Use TCP for the request (virtual circuit)",
"tcp"},
{"no-recurse", NULL, POPT_ARG_NONE, &no_recurse, 0,
"Do not ask recursion",
"no-recurse"},
POPT_AUTOHELP POPT_TABLEEND
};
dns_poptcon = poptGetContext(NULL, argc,
argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt(dns_poptcon)) > 0) {
}
if (value < -1) {
sprintf(msg, "%s: %s",
poptBadOption(dns_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror(value));
dns_usage(msg);
}
hostname = (char *) poptGetArg(dns_poptcon); /* Not used */
request = (char *) poptGetArg(dns_poptcon);
if (request == NULL)
dns_usage("Mandatory request missing");
if ((type_name == NULL) || !strcmp(type_name, "")) {
type = T_A;
type_name = "A";
} else {
upper_type_name = (char *) to_upper(type_name);
/*
* TODO: a better algorithm. Use dns_rdatatype_fromtext in
* BIND ?
*/
if (!strcmp(upper_type_name, "A"))
type = T_A;
else if (!strcmp(upper_type_name, "AAAA"))
type = T_AAAA;
else if (!strcmp(upper_type_name, "NS"))
type = T_NS;
else if (!strcmp(upper_type_name, "SOA"))
type = T_SOA;
else if (!strcmp(upper_type_name, "MX"))
type = T_MX;
else if (!strcmp(upper_type_name, "SRV"))
type = T_SRV;
else if (!strcmp(upper_type_name, "CNAME"))
type = T_CNAME;
else if (!strcmp(upper_type_name, "PTR"))
type = T_PTR;
else if (!strcmp(upper_type_name, "TXT"))
type = T_TXT;
else if (!strcmp(upper_type_name, "ANY"))
type = T_ANY;
else
dns_usage("Unknown type");
}
return "domain";
}
void
start (struct addrinfo *res)
start(struct addrinfo *res)
{
struct sockaddr name_server_sockaddr;
struct sockaddr_in name_server_sockaddr_in;
struct sockaddr_in6 name_server_sockaddr_in6;
name_server = *res;
name_server_sockaddr = *name_server.ai_addr;
if (name_server_sockaddr.sa_family == AF_INET)
{
/* Converts a generic sockaddr to an IPv4 sockaddr_in */
(void) memcpy ((void *) &name_server_sockaddr_in, &name_server_sockaddr,
sizeof (struct sockaddr));
}
else if (name_server_sockaddr.sa_family == AF_INET6)
{
/* TODO: the code for IPv6 servers is hopelessly broken. Start again */
fprintf (stderr, "WARNING: IPv6 nameservers not really supported yet (experts may apply). Falling back to IPv4 and the default server. You may use -4, too\n");
struct sockaddr name_server_sockaddr;
struct sockaddr_in name_server_sockaddr_in;
struct sockaddr_in6 name_server_sockaddr_in6;
name_server = *res;
name_server_sockaddr = *name_server.ai_addr;
if (name_server_sockaddr.sa_family == AF_INET) {
/* Converts a generic sockaddr to an IPv4 sockaddr_in */
(void) memcpy((void *) &name_server_sockaddr_in,
&name_server_sockaddr, sizeof(struct sockaddr));
} else if (name_server_sockaddr.sa_family == AF_INET6) {
/* TODO: the code for IPv6 servers is hopelessly broken. Start again
*/
fprintf(stderr,
"WARNING: IPv6 nameservers not really supported yet (experts may apply). Falling back to IPv4 and the default server. You may use -4, too\n");
#ifdef HAVE_RES_EXT
/* Converts a generic sockaddr to an IPv6 sockaddr_in6 */
(void) memcpy ((void *) &name_server_sockaddr_in6,
&name_server_sockaddr, sizeof (struct sockaddr));
/* Converts a generic sockaddr to an IPv6 sockaddr_in6 */
(void) memcpy((void *) &name_server_sockaddr_in6,
&name_server_sockaddr, sizeof(struct sockaddr));
#else
err_quit
("IPv6 name servers not supported on this platform, may be you should use the -4 option");
err_quit
("IPv6 name servers not supported on this platform, may be you should use the -4 option");
#endif
}
else
{
err_quit ("Unknown family for address of the server");
}
if (res_init () < 0)
err_sys ("res_init");
if (name_server_sockaddr.sa_family == AF_INET)
{
_res.nsaddr_list[0] = name_server_sockaddr_in;
}
else if (name_server_sockaddr.sa_family == AF_INET6)
{
} else {
err_quit("Unknown family for address of the server");
}
if (res_init() < 0)
err_sys("res_init");
if (name_server_sockaddr.sa_family == AF_INET) {
_res.nsaddr_list[0] = name_server_sockaddr_in;
} else if (name_server_sockaddr.sa_family == AF_INET6) {
#ifdef HAVE_RES_EXT
/* TODO: completely broken, dioes not work. Check in Stevens */
(void)memcpy(_res_ext.nsaddr_list, &name_server_sockaddr_in6, sizeof(struct sockaddr_in6));
(void) memcpy(_res_ext.nsaddr_list, &name_server_sockaddr_in6,
sizeof(struct sockaddr_in6));
#endif
}
_res.nscount = 1;
_res.options &= ~(RES_DNSRCH | RES_DEFNAMES | RES_NOALIASES);
if (use_tcp)
{
_res.options |= RES_USEVC;
}
if (no_recurse)
{
_res.options &= ~RES_RECURSE;
}
}
_res.nscount = 1;
_res.options &= ~(RES_DNSRCH | RES_DEFNAMES | RES_NOALIASES);
if (use_tcp) {
_res.options |= RES_USEVC;
}
if (no_recurse) {
_res.options &= ~RES_RECURSE;
}
}
int
execute ()
execute()
{
union
{
HEADER hdr; /* defined in resolv.h */
u_char buf[PACKETSZ]; /* defined in arpa/nameser.h */
} response; /* response buffers */
int response_length; /* buffer length */
if ((response_length = res_query (request, /* the domain we care
* about */
C_IN, /* Internet class records */
type, (u_char *) & response, /* response buffer */
sizeof (response))) /* buffer size */
< 0)
{ /* If negative */
nsError (h_errno, request); /* report the error */
if (h_errno == TRY_AGAIN)
return -1; /* More luck next time? */
else
return -2; /* Give in */
}
/*
* TODO: better analysis of the replies. For instance, replies can be
* in the authority section (delegation info)
*/
return 0;
union {
HEADER hdr; /* defined in resolv.h */
u_char buf[PACKETSZ]; /* defined in arpa/nameser.h */
} response; /* response buffers */
int response_length; /* buffer length */
if ((response_length = res_query(request, /* the domain we care about */
C_IN, /* Internet class records */
type, (u_char *) & response, /* response
* buffer */
sizeof(response))) /* buffer size */
<0) { /* If negative */
nsError(h_errno, request); /* report the error */
if (h_errno == TRY_AGAIN)
return -1; /* More luck next time? */
else
return -2; /* Give in */
}
/*
* TODO: better analysis of the replies. For instance, replies can be
* in the authority section (delegation info)
*/
return 0;
}
void
terminate ()
terminate()
{
}

254
SRC/plugins/ldap/ldap.c
Unescape Escape View File

@ -11,153 +11,149 @@
#endif
#include <ldap.h>
const char *request = NULL;
const char *base = NULL;
int scope = LDAP_SCOPE_BASE;
const char *hostname;
int port = 0;
LDAP *session;
poptContext ldap_poptcon;
const char *request = NULL;
const char *base = NULL;
int scope = LDAP_SCOPE_BASE;
const char *hostname;
int port = 0;
LDAP *session;
poptContext ldap_poptcon;
echoping_options global_options;
void
ldap_usage (const char *msg)
ldap_usage(const char *msg)
{
if (msg)
{
printf ("LDAP plugin error: %s\n", msg);
}
poptPrintUsage (ldap_poptcon, stdout, 0);
exit (1);
if (msg) {
printf("LDAP plugin error: %s\n", msg);
}
poptPrintUsage(ldap_poptcon, stdout, 0);
exit(1);
}
char *
init (const int argc, const char **argv,
const echoping_options global_external_options)
char *
init(const int argc, const char **argv,
const echoping_options global_external_options)
{
int value;
char *msg = malloc (MAX_LINE);
char *rest, *port_text;
char *scope_string = NULL;
/* popt variables */
struct poptOption options[] = {
{"request", 'r', POPT_ARG_STRING, &request, 0,
"Request (filter) to send to the LDAP server", "r"},
{"base", 'b', POPT_ARG_STRING, &base, 0,
"Base of the LDAP tree", "b"},
{"scope", 's', POPT_ARG_STRING, &scope_string, 0,
"Scope of the search in the LDAP tree (sub, one or base)", "s"},
{"port", 'p', POPT_ARG_INT, &port, 0,
"TCP port to connect to the LDAP server", "p"},
POPT_AUTOHELP POPT_TABLEEND
};
global_options = global_external_options;
if (global_options.udp)
err_quit ("UDP makes no sense for a LDAP connection");
ldap_poptcon = poptGetContext (NULL, argc,
argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt (ldap_poptcon)) > 0)
{
}
if (value < -1)
{
sprintf (msg, "%s: %s",
poptBadOption (ldap_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror (value));
ldap_usage (msg);
}
if (port == 0)
port = LDAP_PORT;
hostname = poptGetArg (ldap_poptcon);
rest = poptGetArg (ldap_poptcon);
if (rest != NULL)
{
fprintf (stderr, "%s: ", rest);
ldap_usage ("Additional arguments");
}
if (base == NULL)
base = "";
if (request == NULL || !strcmp (request, ""))
request = "(objectclass=*)";
if (scope_string != NULL)
{
scope_string = to_upper (scope_string);
if (!strcmp (scope_string, "BASE"))
scope = LDAP_SCOPE_BASE;
else if (!strcmp (scope_string, "SUB"))
scope = LDAP_SCOPE_SUBTREE;
else if (!strcmp (scope_string, "ONE"))
scope = LDAP_SCOPE_ONELEVEL;
else
err_quit ("Invalid scope \"%s\"", scope_string);
}
if (port == LDAP_PORT)
{
return "ldap";
}
else
{
port_text = malloc (99);
sprintf (port_text, "%d", port);
return port_text;
}
int value;
char *msg = malloc(MAX_LINE);
char *rest, *port_text;
char *scope_string = NULL;
/* popt variables */
struct poptOption options[] = {
{"request", 'r', POPT_ARG_STRING, &request, 0,
"Request (filter) to send to the LDAP server", "r"},
{"base", 'b', POPT_ARG_STRING, &base, 0,
"Base of the LDAP tree", "b"},
{"scope", 's', POPT_ARG_STRING, &scope_string, 0,
"Scope of the search in the LDAP tree (sub, one or base)", "s"},
{"port", 'p', POPT_ARG_INT, &port, 0,
"TCP port to connect to the LDAP server", "p"},
POPT_AUTOHELP POPT_TABLEEND
};
global_options = global_external_options;
if (global_options.udp)
err_quit("UDP makes no sense for a LDAP connection");
ldap_poptcon = poptGetContext(NULL, argc,
argv, options, POPT_CONTEXT_KEEP_FIRST);
while ((value = poptGetNextOpt(ldap_poptcon)) > 0) {
}
if (value < -1) {
sprintf(msg, "%s: %s",
poptBadOption(ldap_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror(value));
ldap_usage(msg);
}
if (port == 0)
port = LDAP_PORT;
hostname = poptGetArg(ldap_poptcon);
rest = poptGetArg(ldap_poptcon);
if (rest != NULL) {
fprintf(stderr, "%s: ", rest);
ldap_usage("Additional arguments");
}
if (base == NULL)
base = "";
if (request == NULL || !strcmp(request, ""))
request = "(objectclass=*)";
if (scope_string != NULL) {
scope_string = to_upper(scope_string);
if (!strcmp(scope_string, "BASE"))
scope = LDAP_SCOPE_BASE;
else if (!strcmp(scope_string, "SUB"))
scope = LDAP_SCOPE_SUBTREE;
else if (!strcmp(scope_string, "ONE"))
scope = LDAP_SCOPE_ONELEVEL;
else
err_quit("Invalid scope \"%s\"", scope_string);
}
if (port == LDAP_PORT) {
return "ldap";
} else {
port_text = malloc(99);
sprintf(port_text, "%d", port);
return port_text;
}
}
void
start ()
start()
{
int result;
LDAPMessage *response;
int result;
LDAPMessage *response;
session = ldap_init (hostname, port);
if (session == NULL)
err_sys ("Cannot initialize LDAP");
/* TODO: allow non-anonymous connections, with ldap_bind_simple_s */
/*
* Unfortunately, ldap_init does not connect to the LDAP server. So
* connection errors (e.g. firewall), will not be detected here and
* loop will go on.
*
* To quote the man page: ldap_init() acts just like ldap_open(), but
* does not open a connection to the LDAP server. The actual
* connection open will occur when the first operation is attempted.
* At this time, ldap_init() is preferred. ldap_open() will be
* depreciated in a later release.
*
* So, we perform a dummy search immediately.
*/
result = ldap_search_s (session, base, LDAP_SCOPE_ONELEVEL, "(objectclass=*)", NULL, /* Return all attributes */
1, &response);
if (result != 0)
{
err_quit
("Cannot connect to %s (no LDAP server or wrong base, probably): %s",
hostname, ldap_err2string (result));
}
session = ldap_init(hostname, port);
if (session == NULL)
err_sys("Cannot initialize LDAP");
/* TODO: allow non-anonymous connections, with ldap_bind_simple_s */
/*
* Unfortunately, ldap_init does not connect to the LDAP server. So
* connection errors (e.g. firewall), will not be detected here and
* loop will go on.
*
* To quote the man page: ldap_init() acts just like ldap_open(), but
* does not open a connection to the LDAP server. The actual
* connection open will occur when the first operation is attempted.
* At this time, ldap_init() is preferred. ldap_open() will be
* depreciated in a later release.
*
* So, we perform a dummy search immediately.
*/
result = ldap_search_s(session, base, LDAP_SCOPE_ONELEVEL, "(objectclass=*)", NULL, /* Return
* all
* attributes
*/
1, &response);
if (result != 0) {
err_quit
("Cannot connect to %s (no LDAP server or wrong base, probably): %s",
hostname, ldap_err2string(result));
}
}
int
execute ()
execute()
{
int result;
LDAPMessage *response;
result = ldap_search_s (session, base, scope, request, NULL, /* Return all attributes */
0, /* Return attribute types *and*
* values */
&response);
if (result != 0)
{
err_ret ("Cannot search \"%s\": %s", request, ldap_err2string (result));
return -1;
}
if (global_options.verbose)
printf ("Retrieved: %d entries\n",
ldap_count_entries (session, response));
return 0;
int result;
LDAPMessage *response;
result = ldap_search_s(session, base, scope, request, NULL, /* Return
* all
* attributes
*/
0, /* Return attribute types *and* values */
&response);
if (result != 0) {
err_ret("Cannot search \"%s\": %s", request,
ldap_err2string(result));
return -1;
}
if (global_options.verbose)
printf("Retrieved: %d entries\n",
ldap_count_entries(session, response));
return 0;
}
void
terminate ()
terminate()
{
ldap_unbind_s (session);
ldap_unbind_s(session);
}

221
SRC/plugins/postgresql/postgresql.c
Unescape Escape View File

@ -16,145 +16,132 @@
#include <libpq-fe.h>
#endif
const char *request = NULL;
int readall = FALSE;
int connect_each_time = FALSE;
poptContext postgresql_poptcon;
PGconn *conn;
PGresult *res;
char *conninfo;
const char *request = NULL;
int readall = FALSE;
int connect_each_time = FALSE;
poptContext postgresql_poptcon;
PGconn *conn;
PGresult *res;
char *conninfo;
echoping_options global_options;
void
postgresql_usage (const char *msg)
postgresql_usage(const char *msg)
{
if (msg)
{
printf ("PostgreSQL plugin error: %s\n", msg);
}
poptPrintUsage (postgresql_poptcon, stdout, 0);
fprintf (stderr, " [SQL-request]\n");
exit (1);
if (msg) {
printf("PostgreSQL plugin error: %s\n", msg);
}
poptPrintUsage(postgresql_poptcon, stdout, 0);
fprintf(stderr, " [SQL-request]\n");
exit(1);
}
char *
init (const int argc, const char **argv,
const echoping_options global_external_options)
char *
init(const int argc, const char **argv,
const echoping_options global_external_options)
{
int value;
char *msg = malloc (256);
char *rest;
/* popt variables */
struct poptOption options[] = {
{"conninfo", 'c', POPT_ARG_STRING, &conninfo, 0,
"Connection information for the Postgresql server. Something like 'host=foo dbname=bar''",
""},
{"readall", 'a', POPT_ARG_NONE, &readall, 0,
"Read all the data sent by the Postgresql server",
""},
{"connect-each-time", 'e', POPT_ARG_NONE, &connect_each_time, 0,
"(Re)Connect to the Postgresql server at each iteration",
""},
POPT_AUTOHELP POPT_TABLEEND
};
global_options = global_external_options;
if (global_options.udp)
err_quit ("UDP makes no sense for a PostgreSQL connection");
postgresql_poptcon = poptGetContext (NULL, argc,
argv, options,
POPT_CONTEXT_POSIXMEHARDER);
while ((value = poptGetNextOpt (postgresql_poptcon)) > 0)
{
}
if (value < -1)
{
sprintf (msg, "%s: %s",
poptBadOption (postgresql_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror (value));
postgresql_usage (msg);
}
request = poptGetArg (postgresql_poptcon);
if (request == NULL)
request = "SELECT now()";
rest = poptGetArg (postgresql_poptcon);
if (rest != NULL)
postgresql_usage ("Erroneous additional arguments");
if (conninfo == NULL)
conninfo = "";
return NULL; /* We only use the conninfo, echoping does not see our hostname or port */
int value;
char *msg = malloc(256);
char *rest;
/* popt variables */
struct poptOption options[] = {
{"conninfo", 'c', POPT_ARG_STRING, &conninfo, 0,
"Connection information for the Postgresql server. Something like 'host=foo dbname=bar''",
""},
{"readall", 'a', POPT_ARG_NONE, &readall, 0,
"Read all the data sent by the Postgresql server",
""},
{"connect-each-time", 'e', POPT_ARG_NONE, &connect_each_time, 0,
"(Re)Connect to the Postgresql server at each iteration",
""},
POPT_AUTOHELP POPT_TABLEEND
};
global_options = global_external_options;
if (global_options.udp)
err_quit("UDP makes no sense for a PostgreSQL connection");
postgresql_poptcon = poptGetContext(NULL, argc,
argv, options,
POPT_CONTEXT_POSIXMEHARDER);
while ((value = poptGetNextOpt(postgresql_poptcon)) > 0) {
}
if (value < -1) {
sprintf(msg, "%s: %s",
poptBadOption(postgresql_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror(value));
postgresql_usage(msg);
}
request = poptGetArg(postgresql_poptcon);
if (request == NULL)
request = "SELECT now()";
rest = poptGetArg(postgresql_poptcon);
if (rest != NULL)
postgresql_usage("Erroneous additional arguments");
if (conninfo == NULL)
conninfo = "";
return NULL; /* We only use the conninfo, echoping does not see
* our hostname or port */
}
void
start_raw ()
start_raw()
{
if (!connect_each_time)
{
conn = PQconnectdb (conninfo);
if (conn == NULL)
{
err_quit ("Cannot create connection\n");
}
if (PQstatus (conn) == CONNECTION_BAD)
{
err_quit ("Connection failed: %s\n", PQerrorMessage (conn));
if (!connect_each_time) {
conn = PQconnectdb(conninfo);
if (conn == NULL) {
err_quit("Cannot create connection\n");
}
if (PQstatus(conn) == CONNECTION_BAD) {
err_quit("Connection failed: %s\n", PQerrorMessage(conn));
}
}
}
}
int
execute ()
execute()
{
unsigned int row, column;
char *result;
if (connect_each_time)
{
conn = PQconnectdb (conninfo);
if (conn == NULL)
{
err_ret ("Cannot create connection\n");
return -1;
unsigned int row, column;
char *result;
if (connect_each_time) {
conn = PQconnectdb(conninfo);
if (conn == NULL) {
err_ret("Cannot create connection\n");
return -1;
}
if (PQstatus(conn) == CONNECTION_BAD) {
err_ret("Connection failed: %s\n", PQerrorMessage(conn));
return -1;
}
}
if (PQstatus (conn) == CONNECTION_BAD)
{
err_ret ("Connection failed: %s\n", PQerrorMessage (conn));
return -1;
res = PQexec(conn, request);
if (PQresultStatus(res) != PGRES_TUPLES_OK) {
err_ret("Cannot run \"%s\": %s\n", request,
PQresultErrorMessage(res));
return -1;
}
}
res = PQexec (conn, request);
if (PQresultStatus (res) != PGRES_TUPLES_OK)
{
err_ret ("Cannot run \"%s\": %s\n", request,
PQresultErrorMessage (res));
return -1;
}
if (global_options.verbose)
printf ("%d tuples returned\n", PQntuples (res));
if (readall)
{
for (row = 0; row < PQntuples (res); row++)
{
for (column = 0; column < PQnfields (res); column++)
{
result = PQgetvalue (res, row, column);
if (result == NULL)
{
err_ret ("Cannot retrieve value [%d,%d]\n", row, column);
return -1;
if (global_options.verbose)
printf("%d tuples returned\n", PQntuples(res));
if (readall) {
for (row = 0; row < PQntuples(res); row++) {
for (column = 0; column < PQnfields(res); column++) {
result = PQgetvalue(res, row, column);
if (result == NULL) {
err_ret("Cannot retrieve value [%d,%d]\n",
row, column);
return -1;
}
/* else { printf ("DEBUG: [%d,%d] %s\n", row,
* column, result); } */
}
}
/* else {
printf ("DEBUG: [%d,%d] %s\n", row, column, result);
} */
}
}
}
if (connect_each_time)
PQfinish (conn);
return 0;
if (connect_each_time)
PQfinish(conn);
return 0;
}
void
terminate ()
terminate()
{
if (!connect_each_time)
PQfinish (conn);
if (!connect_each_time)
PQfinish(conn);
}

27
SRC/plugins/random/random.c
Unescape Escape View File

@ -9,24 +9,29 @@
#include <time.h>
#include <unistd.h>
char *
init (const int argc, const char *argv[])
char *
init(const int argc, const char *argv[])
{
struct timeval tv;
(void) gettimeofday (&tv, (struct timezone *) NULL);
srand (tv.tv_usec);
return "7"; /* Not used, just to say we use the cooked interface */
struct timeval tv;
(void) gettimeofday(&tv, (struct timezone *) NULL);
srand(tv.tv_usec);
return "7"; /* Not used, just to say we use the cooked interface
*/
}
void start ()
void
start()
{
}
int
execute ()
execute()
{
usleep (rand () % 1000000);
return 1;
usleep(rand() % 1000000);
return 1;
}
void terminate() {}
void
terminate()
{
}

163
SRC/plugins/whois/whois.c
Unescape Escape View File

@ -14,106 +14,103 @@
#define MAX_REQUEST 256
struct addrinfo whois_server;
char *hostname;
const char *request = NULL;
int dump = FALSE;
int n;
int sockfd;
FILE *files = NULL;
poptContext whois_poptcon;
char *hostname;
const char *request = NULL;
int dump = FALSE;
int n;
int sockfd;
FILE *files = NULL;
poptContext whois_poptcon;
void
whois_usage (const char *msg)
whois_usage(const char *msg)
{
if (msg)
{
printf ("Error: %s\n", msg);
}
poptPrintUsage (whois_poptcon, stdout, 0);
fprintf (stderr, " request\n");
exit (1);
if (msg) {
printf("Error: %s\n", msg);
}
poptPrintUsage(whois_poptcon, stdout, 0);
fprintf(stderr, " request\n");
exit(1);
}
char *
init (const int argc, const char **argv, echoping_options global_options)
char *
init(const int argc, const char **argv, echoping_options global_options)
{
int value;
char *msg = malloc (256);
char *rest;
/* popt variables */
struct poptOption options[] = {
{"dump", 'd', POPT_ARG_NONE, &dump, 'd',
"Dumps the reply from the whois server",
""},
POPT_AUTOHELP POPT_TABLEEND
};
if (global_options.udp)
err_quit ("UDP is incompatible with this whois plugin");
/* Will probably be catched before because /etc/services have no entry for UDP port 43 */
whois_poptcon = poptGetContext (NULL, argc,
argv, options, POPT_CONTEXT_POSIXMEHARDER);
while ((value = poptGetNextOpt (whois_poptcon)) > 0)
{
switch ((char) value)
{
case 'd':
break;
default:
sprintf (msg, "Wrong option %d (%c)", value, (char) value);
whois_usage (msg);
int value;
char *msg = malloc(256);
char *rest;
/* popt variables */
struct poptOption options[] = {
{"dump", 'd', POPT_ARG_NONE, &dump, 'd',
"Dumps the reply from the whois server",
""},
POPT_AUTOHELP POPT_TABLEEND
};
if (global_options.udp)
err_quit("UDP is incompatible with this whois plugin");
/* Will probably be catched before because /etc/services have no entry for
* UDP port 43 */
whois_poptcon = poptGetContext(NULL, argc,
argv, options, POPT_CONTEXT_POSIXMEHARDER);
while ((value = poptGetNextOpt(whois_poptcon)) > 0) {
switch ((char) value) {
case 'd':
break;
default:
sprintf(msg, "Wrong option %d (%c)", value, (char) value);
whois_usage(msg);
}
}
if (value < -1) {
sprintf(msg, "%s: %s",
poptBadOption(whois_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror(value));
whois_usage(msg);
}
}
if (value < -1)
{
sprintf (msg, "%s: %s",
poptBadOption (whois_poptcon, POPT_BADOPTION_NOALIAS),
poptStrerror (value));
whois_usage (msg);
}
request = (char *) poptGetArg (whois_poptcon);
if (request == NULL)
whois_usage ("Mandatory request missing");
rest = (char *) poptGetArg (whois_poptcon);
if (rest != NULL && strcmp (rest, ""))
whois_usage ("Extraneous arguments ignored");
return "nicname";
request = (char *) poptGetArg(whois_poptcon);
if (request == NULL)
whois_usage("Mandatory request missing");
rest = (char *) poptGetArg(whois_poptcon);
if (rest != NULL && strcmp(rest, ""))
whois_usage("Extraneous arguments ignored");
return "nicname";
}
void
start (struct addrinfo *res)
start(struct addrinfo *res)
{
whois_server = *res;
whois_server = *res;
}
int
execute ()
execute()
{
int nr = 0;
char recvline[MAX_LINE + 1];
char complete_request[MAX_REQUEST];
if ((sockfd =
socket (whois_server.ai_family, whois_server.ai_socktype,
whois_server.ai_protocol)) < 0)
err_sys ("Can't open socket");
if (connect (sockfd, whois_server.ai_addr, whois_server.ai_addrlen) < 0)
err_sys ("Can't connect to server");
if ((files = fdopen (sockfd, "r")) == NULL)
err_sys ("Cannot fdopen");
sprintf (complete_request, "%s\r\n", request);
n = strlen (complete_request);
if (writen (sockfd, complete_request, n) != n)
err_sys ("writen error on socket");
/* Read from the server */
while ((nr = readline (files, recvline, MAX_LINE, 0)) > 0)
if (dump)
printf ("%s", recvline);
if (dump)
printf ("\n");
close (sockfd);
return 1;
int nr = 0;
char recvline[MAX_LINE + 1];
char complete_request[MAX_REQUEST];
if ((sockfd =
socket(whois_server.ai_family, whois_server.ai_socktype,
whois_server.ai_protocol)) < 0)
err_sys("Can't open socket");
if (connect(sockfd, whois_server.ai_addr, whois_server.ai_addrlen) < 0)
err_sys("Can't connect to server");
if ((files = fdopen(sockfd, "r")) == NULL)
err_sys("Cannot fdopen");
sprintf(complete_request, "%s\r\n", request);
n = strlen(complete_request);
if (writen(sockfd, complete_request, n) != n)
err_sys("writen error on socket");
/* Read from the server */
while ((nr = readline(files, recvline, MAX_LINE, 0)) > 0)
if (dump)
printf("%s", recvline);
if (dump)
printf("\n");
close(sockfd);
return 1;
}
void
terminate ()
terminate()
{
}

354
SRC/readline.c
Unescape Escape View File

@ -8,219 +8,189 @@
#include "echoping.h"
int
readline (fs, ptr, maxlen, ln)
FILE *fs;
char *ptr;
int maxlen;
unsigned short ln;
readline(fs, ptr, maxlen, ln)
FILE *fs;
char *ptr;
int maxlen;
unsigned short ln;
{
int n = 1;
char *rc;
int r;
int n = 1;
char *rc;
int r;
/* Reading with fgets or fread instead of read
one-character-at-a-time is more than ten times faster, on a local
server. */
if (ln)
{
rc = fgets (ptr, maxlen + 1, fs);
if (rc == NULL)
{
if (timeout_flag)
return n;
return (-1);
}
n = strlen (rc);
return n;
}
else
{
while (n < maxlen)
{
r = fread (ptr, 1, maxlen, fs);
if (timeout_flag)
return r;
if (r == 0)
{
if (n == 1)
return (0); /* EOF, no data read */
else
break; /* EOF, some data was read */
}
n = n + r;
/* Reading with fgets or fread instead of read one-character-at-a-time is
* more than ten times faster, on a local server. */
if (ln) {
rc = fgets(ptr, maxlen + 1, fs);
if (rc == NULL) {
if (timeout_flag)
return n;
return (-1);
}
n = strlen(rc);
return n;
} else {
while (n < maxlen) {
r = fread(ptr, 1, maxlen, fs);
if (timeout_flag)
return r;
if (r == 0) {
if (n == 1)
return (0); /* EOF, no data read */
else
break; /* EOF, some data was read */
}
n = n + r;
}
}
}
return (n);
return (n);
}
#ifdef OPENSSL
char SSL_buffer[MAXTOREAD];
int buf_ptr;
int buf_end;
char SSL_buffer[MAXTOREAD];
int buf_ptr;
int buf_end;
int
SSL_readline (sslh, ptr, maxlen, ln)
SSL *sslh;
char *ptr;
int maxlen;
unsigned short ln;
SSL_readline(sslh, ptr, maxlen, ln)
SSL *sslh;
char *ptr;
int maxlen;
unsigned short ln;
{
int rc = 0;
int n = 0;
int i, oi;
if (ln)
{
/* Empty buffer */
if (buf_end == 0)
{
rc = SSL_read (sslh, SSL_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
buf_ptr = 0;
}
/* No more data in the buffer */
else if (buf_ptr == buf_end)
{
buf_ptr = 0;
rc = SSL_read (sslh, SSL_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
}
else if (SSL_buffer[buf_end] != '\n')
{
/* We have a probleme here is the first SSL_read sent back
a text not finished by a \n. See www.SSL.de for an
example. We get more data. See bug #230384 */
rc = SSL_read (sslh, SSL_buffer + buf_end, maxlen);
if (rc == -1)
return rc;
buf_end = buf_end + rc;
}
for (oi = buf_ptr, i = buf_ptr;
i <= buf_end && SSL_buffer[i] != '\n'; i++)
{
*ptr++ = SSL_buffer[i];
buf_ptr++;
}
if (SSL_buffer[i] == '\n')
buf_ptr++;
*ptr = '\0';
/* if (ln)
printf ("SSL_readline returns %d (%s)\n", i - oi, SSL_buffer); */
return (i - oi);
}
else
{
/* OpenSSL reads at most 4096 characters */
rc = 1; /* Just to avoid exiting too soon */
while (n < maxlen && rc != 0)
{
if ((buf_end == 0) || (buf_ptr > buf_end))
{
rc = SSL_read (sslh, ptr, maxlen);
buf_end = 0;
buf_ptr = 0;
}
else
{
for (i = buf_ptr; i < maxlen && i <= buf_end; i++)
{
*ptr++ = SSL_buffer[i];
rc++;
int rc = 0;
int n = 0;
int i, oi;
if (ln) {
/* Empty buffer */
if (buf_end == 0) {
rc = SSL_read(sslh, SSL_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
buf_ptr = 0;
}
/* No more data in the buffer */
else if (buf_ptr == buf_end) {
buf_ptr = 0;
rc = SSL_read(sslh, SSL_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
} else if (SSL_buffer[buf_end] != '\n') {
/* We have a probleme here is the first SSL_read sent back a
* text not finished by a \n. See www.SSL.de for an example.
* We get more data. See bug #230384 */
rc = SSL_read(sslh, SSL_buffer + buf_end, maxlen);
if (rc == -1)
return rc;
buf_end = buf_end + rc;
}
for (oi = buf_ptr, i = buf_ptr;
i <= buf_end && SSL_buffer[i] != '\n'; i++) {
*ptr++ = SSL_buffer[i];
buf_ptr++;
}
buf_ptr = i;
}
n = n + rc;
if (SSL_buffer[i] == '\n')
buf_ptr++;
*ptr = '\0';
/* if (ln) printf ("SSL_readline returns %d (%s)\n", i - oi,
* SSL_buffer); */
return (i - oi);
} else {
/* OpenSSL reads at most 4096 characters */
rc = 1; /* Just to avoid exiting too soon */
while (n < maxlen && rc != 0) {
if ((buf_end == 0) || (buf_ptr > buf_end)) {
rc = SSL_read(sslh, ptr, maxlen);
buf_end = 0;
buf_ptr = 0;
} else {
for (i = buf_ptr; i < maxlen && i <= buf_end; i++) {
*ptr++ = SSL_buffer[i];
rc++;
}
buf_ptr = i;
}
n = n + rc;
}
return n;
}
return n;
}
}
#endif
#ifdef GNUTLS
char TLS_buffer[MAXTOREAD];
int buf_ptr;
int buf_end;
char TLS_buffer[MAXTOREAD];
int buf_ptr;
int buf_end;
int
TLS_readline (session, ptr, maxlen, ln)
gnutls_session session;
char *ptr;
int maxlen;
unsigned short ln;
TLS_readline(session, ptr, maxlen, ln)
gnutls_session session;
char *ptr;
int maxlen;
unsigned short ln;
{
int rc = 0;
int n = 0;
int i, oi;
if (ln)
{
/* Empty buffer */
if (buf_end == 0)
{
rc = gnutls_record_recv (session, TLS_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
buf_ptr = 0;
}
/* No more data in the buffer */
else if (buf_ptr == buf_end)
{
buf_ptr = 0;
rc = gnutls_record_recv (session, TLS_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
}
else if (TLS_buffer[buf_end] != '\n')
{
rc = gnutls_record_recv (session, TLS_buffer + buf_end, maxlen);
if (rc == -1)
return rc;
buf_end = buf_end + rc;
}
for (oi = buf_ptr, i = buf_ptr;
i <= buf_end && TLS_buffer[i] != '\n'; i++)
{
*ptr++ = TLS_buffer[i];
buf_ptr++;
}
if (TLS_buffer[i] == '\n')
buf_ptr++;
*ptr = '\0';
/* printf ("DEBUG: TLS_readline returns %d (%s)\n", i - oi, TLS_buffer); */
return (i - oi);
}
else
{
rc = 1; /* Just to avoid exiting too soon */
while (n < maxlen && rc > 0)
{
if ((buf_end == 0) || (buf_ptr > buf_end))
{
rc = gnutls_record_recv (session, ptr, maxlen);
buf_end = 0;
buf_ptr = 0;
}
else
{
for (i = buf_ptr; i < maxlen && i <= buf_end; i++)
{
*ptr++ = TLS_buffer[i];
rc++;
/* printf ("DEBUG: Now %d chars read\n", rc); */
int rc = 0;
int n = 0;
int i, oi;
if (ln) {
/* Empty buffer */
if (buf_end == 0) {
rc = gnutls_record_recv(session, TLS_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
buf_ptr = 0;
}
/* No more data in the buffer */
else if (buf_ptr == buf_end) {
buf_ptr = 0;
rc = gnutls_record_recv(session, TLS_buffer, maxlen);
if (rc == -1)
return rc;
buf_end = rc;
} else if (TLS_buffer[buf_end] != '\n') {
rc = gnutls_record_recv(session, TLS_buffer + buf_end,
maxlen);
if (rc == -1)
return rc;
buf_end = buf_end + rc;
}
for (oi = buf_ptr, i = buf_ptr;
i <= buf_end && TLS_buffer[i] != '\n'; i++) {
*ptr++ = TLS_buffer[i];
buf_ptr++;
}
if (TLS_buffer[i] == '\n')
buf_ptr++;
*ptr = '\0';
/* printf ("DEBUG: TLS_readline returns %d (%s)\n", i - oi,
* TLS_buffer); */
return (i - oi);
} else {
rc = 1; /* Just to avoid exiting too soon */
while (n < maxlen && rc > 0) {
if ((buf_end == 0) || (buf_ptr > buf_end)) {
rc = gnutls_record_recv(session, ptr, maxlen);
buf_end = 0;
buf_ptr = 0;
} else {
for (i = buf_ptr; i < maxlen && i <= buf_end; i++) {
*ptr++ = TLS_buffer[i];
rc++;
/* printf ("DEBUG: Now %d chars read\n",
* rc); */
}
buf_ptr = i;
}
if (rc > 0)
n = n + rc;
/* printf ("DEBUG: Now %d chars to send\n", n); */
}
buf_ptr = i;
}
if (rc > 0)
n = n + rc;
/* printf ("DEBUG: Now %d chars to send\n", n); */
return n;
}
return n;
}
}
#endif

38
SRC/smtp.c
Unescape Escape View File

@ -8,31 +8,27 @@
#ifdef SMTP
char big_recvline[MAXTOREAD];
char big_recvline[MAXTOREAD];
int
smtp_read_response_from_server (FILE *fs)
smtp_read_response_from_server(FILE * fs)
{
int nr;
int i;
int nr;
int i;
for (i = 0; i < MAXSMTPLINES; i++)
{
nr = readline (fs, big_recvline, MAXTOREAD, TRUE);
if (nr <= 4)
{
return -1;
for (i = 0; i < MAXSMTPLINES; i++) {
nr = readline(fs, big_recvline, MAXTOREAD, TRUE);
if (nr <= 4) {
return -1;
}
if (big_recvline[3] == ' ') {
return nr;
}
if (big_recvline[3] != '-') {
return -1;
}
}
if (big_recvline[3] == ' ')
{
return nr;
}
if (big_recvline[3] != '-')
{
return -1;
}
}
return -1;
return -1;
}
#endif /* SMTP */
#endif /* SMTP */

260
SRC/util.c
Unescape Escape View File

@ -9,44 +9,43 @@
#include <time.h>
#include <ctype.h>
char *
random_string (unsigned length)
char *
random_string(unsigned length)
{
char *state = (char *) malloc (sizeof (char) * STATES);
char *result = (char *) malloc (length + 1);
int i, number;
unsigned seed = (unsigned) time ((time_t *) NULL);
char *state = (char *) malloc(sizeof(char) * STATES);
char *result = (char *) malloc(length + 1);
int i, number;
unsigned seed = (unsigned) time((time_t *) NULL);
/* printf ("Seed is %u\n", seed); */
/* printf ("Seed is %u\n", seed); */
/* Initialize random generator */
(void) initstate (seed, state, STATES);
/* Initialize random generator */
(void) initstate(seed, state, STATES);
for (i = 0; i < length; i++)
{
number = (random () % 94) + 33;
/* printf ("Number for %d is %d\n", i, number); */
result[i] = (char) number;
}
result[length] = '\0';
for (i = 0; i < length; i++) {
number = (random() % 94) + 33;
/* printf ("Number for %d is %d\n", i, number); */
result[i] = (char) number;
}
result[length] = '\0';
/* printf ("Result is %s\n", result); */
/* printf ("Result is %s\n", result); */
return result;
return result;
}
char *
to_upper (char *input)
char *
to_upper(char *input)
{
int c;
char *result;
result = (char *) malloc (strlen (input));
for (c = 0; c < strlen (input); c++)
result[c] = toupper (input[c]);
result[strlen (input)] = '\0';
return result;
int c;
char *result;
result = (char *) malloc(strlen(input));
for (c = 0; c < strlen(input); c++)
result[c] = toupper(input[c]);
result[strlen(input)] = '\0';
return result;
}
/*
@ -54,155 +53,142 @@ to_upper (char *input)
* >= in. Comes from the bing program.
*/
void
tvsub (out, in)
struct timeval *out, *in;
tvsub(out, in)
struct timeval *out, *in;
{
if ((out->tv_usec -= in->tv_usec) < 0)
{
--out->tv_sec;
out->tv_usec += 1000000;
}
out->tv_sec -= in->tv_sec;
if ((out->tv_usec -= in->tv_usec) < 0) {
--out->tv_sec;
out->tv_usec += 1000000;
}
out->tv_sec -= in->tv_sec;
}
/* tvadd -- Adds 2 timeval structs: out = out + in. */
void
tvadd (out, in)
struct timeval *out, *in;
tvadd(out, in)
struct timeval *out, *in;
{
if ((out->tv_usec += in->tv_usec) >= 1000000)
{
++out->tv_sec;
out->tv_usec -= 1000000;
}
out->tv_sec += in->tv_sec;
if ((out->tv_usec += in->tv_usec) >= 1000000) {
++out->tv_sec;
out->tv_usec -= 1000000;
}
out->tv_sec += in->tv_sec;
}
/* tvavg -- Averages a timeval struct */
void
tvavg (out, number)
struct timeval *out;
int number;
tvavg(out, number)
struct timeval *out;
int number;
{
double result;
/*
* out->tv_sec = out->tv_sec/number; out->tv_usec =
* out->tv_usec/number;
*/
result = (1000000 * out->tv_sec + out->tv_usec) / number;
/* printf ("Result of average is %f\n", result) */ ;
out->tv_sec = (long) (result / 1000000);
out->tv_usec = (long) (result - (out->tv_sec * 1000000));
double result;
/*
* out->tv_sec = out->tv_sec/number; out->tv_usec =
* out->tv_usec/number;
*/
result = (1000000 * out->tv_sec + out->tv_usec) / number;
/* printf ("Result of average is %f\n", result) */ ;
out->tv_sec = (long) (result / 1000000);
out->tv_usec = (long) (result - (out->tv_sec * 1000000));
}
/* tvstddev -- Computes the standard deviation of a set of results */
void
tvstddev (out, number, average, results)
struct timeval *out;
int number;
struct timeval average;
struct result *results;
tvstddev(out, number, average, results)
struct timeval *out;
int number;
struct timeval average;
struct result *results;
{
int i;
struct timeval result, avg, var = null_timeval;
struct timeval square, large, small;
*out = null_timeval;
for (i = 0; i < number; i++)
{
if (results[i].valid == 1)
{
result = results[i].timevalue;
/* printf ("value is %f (average is %f)\n",
tv2double (result), tv2double (average)); */
avg = average;
if (tvcmp (&result, &avg) == -1)
{
small = result;
large = avg;
}
else
{
large = result;
small = avg;
}
tvsub (&large, &small);
/* printf ("abs offset is %f\n", tv2double (large)); */
square = double2tv (pow (tv2double (large), 2));
tvadd (&var, &square);
/* printf ("variance is now %f\n", tv2double (var)); */
int i;
struct timeval result, avg, var = null_timeval;
struct timeval square, large, small;
*out = null_timeval;
for (i = 0; i < number; i++) {
if (results[i].valid == 1) {
result = results[i].timevalue;
/* printf ("value is %f (average is %f)\n", tv2double
* (result), tv2double (average)); */
avg = average;
if (tvcmp(&result, &avg) == -1) {
small = result;
large = avg;
} else {
large = result;
small = avg;
}
tvsub(&large, &small);
/* printf ("abs offset is %f\n", tv2double (large)); */
square = double2tv(pow(tv2double(large), 2));
tvadd(&var, &square);
/* printf ("variance is now %f\n", tv2double (var)); */
}
}
}
result = double2tv (sqrt (tv2double (var) / number));
out->tv_sec = result.tv_sec;
out->tv_usec = result.tv_usec;
result = double2tv(sqrt(tv2double(var) / number));
out->tv_sec = result.tv_sec;
out->tv_usec = result.tv_usec;
}
/* tvcmp -- Compares two timeval structs */
int
tvcmp (left, right)
struct timeval *left, *right;
tvcmp(left, right)
struct timeval *left, *right;
{
if (left->tv_sec < right->tv_sec)
{
return -1;
}
if (left->tv_sec > right->tv_sec)
{
return 1;
}
if (left->tv_usec < right->tv_usec)
{
return -1;
}
if (left->tv_usec > right->tv_usec)
{
return 1;
}
return 0;
if (left->tv_sec < right->tv_sec) {
return -1;
}
if (left->tv_sec > right->tv_sec) {
return 1;
}
if (left->tv_usec < right->tv_usec) {
return -1;
}
if (left->tv_usec > right->tv_usec) {
return 1;
}
return 0;
}
/* tvmin */
void
tvmin (champion, challenger)
struct timeval *champion, *challenger;
tvmin(champion, challenger)
struct timeval *champion, *challenger;
{
if (tvcmp (champion, challenger) == 1)
{
champion->tv_sec = challenger->tv_sec;
champion->tv_usec = challenger->tv_usec;
}
if (tvcmp(champion, challenger) == 1) {
champion->tv_sec = challenger->tv_sec;
champion->tv_usec = challenger->tv_usec;
}
}
/* tvmax */
void
tvmax (champion, challenger)
struct timeval *champion, *challenger;
tvmax(champion, challenger)
struct timeval *champion, *challenger;
{
if (tvcmp (champion, challenger) == -1)
{
champion->tv_sec = challenger->tv_sec;
champion->tv_usec = challenger->tv_usec;
}
if (tvcmp(champion, challenger) == -1) {
champion->tv_sec = challenger->tv_sec;
champion->tv_usec = challenger->tv_usec;
}
}
double
tv2double (tv)
struct timeval tv;
tv2double(tv)
struct timeval tv;
{
double result;
result =
(((((double) tv.tv_sec) * 1000000.0) + (double) tv.tv_usec) / 1000000.0);
/* printf ("Double is %9.3f\n", result); */
return result;
double result;
result =
(((((double) tv.tv_sec) * 1000000.0) + (double) tv.tv_usec) / 1000000.0);
/* printf ("Double is %9.3f\n", result); */
return result;
}
struct timeval
double2tv (x)
double x;
double2tv(x)
double x;
{
struct timeval result;
result.tv_sec = (int) (x);
result.tv_usec = (int) ((x - result.tv_sec) * 1000000);
return result;
struct timeval result;
result.tv_sec = (int) (x);
result.tv_usec = (int) ((x - result.tv_sec) * 1000000);
return result;
}

39
SRC/writen.c
Unescape Escape View File

@ -8,26 +8,25 @@
#include "echoping.h"
int
writen (fd, ptr, nbytes)
register int fd;
register char *ptr;
register int nbytes;
writen(fd, ptr, nbytes)
register int fd;
register char *ptr;
register int nbytes;
{
int nleft, nwritten;
int nleft, nwritten;
nleft = nbytes;
while (nleft > 0)
{
nwritten = write (fd, ptr, nleft);
if (nwritten <= 0)
return (nwritten); /* error */
/* Some systems, such as Digital's OSF1 (Digital Unix) doesn't set the returned
value to -1, even when interrupted by an alarm, whatever says the documentation.
errno is not set. */
if ((nwritten < nleft) && timeout_flag)
return nwritten;
nleft -= nwritten;
ptr += nwritten;
}
return (nbytes - nleft);
nleft = nbytes;
while (nleft > 0) {
nwritten = write(fd, ptr, nleft);
if (nwritten <= 0)
return (nwritten); /* error */
/* Some systems, such as Digital's OSF1 (Digital Unix) doesn't set
* the returned value to -1, even when interrupted by an alarm,
* whatever says the documentation. errno is not set. */
if ((nwritten < nleft) && timeout_flag)
return nwritten;
nleft -= nwritten;
ptr += nwritten;
}
return (nbytes - nleft);
}

Write Preview
Loading…
Cancel
Save