... and return EXIT_SUCCESS from main() functions.
printf("creating hash table\n");
if ((hid = hash_create((HASHCMP *) strcmp, 229, hash4)) < 0) {
printf("hash_create error.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
printf("done creating hash table: %d\n", hid);
printf("done walking hash table...\n");
printf("driver finished.\n");
- exit(0);
+ return EXIT_SUCCESS;
}
#endif
if (rmsgid < 0) {
perror("msgget");
- return 1;
+ exit(EXIT_FAILURE);
}
key = atoi(argv[2]);
if (smsgid < 0) {
perror("msgget");
- return 1;
+ exit(EXIT_FAILURE);
}
key = atoi(argv[3]);
if (shmid < 0) {
perror("shmget");
- return 1;
+ exit(EXIT_FAILURE);
}
shmbuf = (char *)shmat(shmid, NULL, 0);
if (shmbuf == (void *) -1) {
perror("shmat");
- return 1;
+ exit(EXIT_FAILURE);
}
hash = hash_create(fsCmp, 1 << 4, fsHash);
assert(hash);
if (fcntl(0, F_SETFL, SQUID_NONBLOCK) < 0) {
perror(xstrerr(errno));
- return 1;
+ exit(EXIT_FAILURE);
}
memset(&sa, '\0', sizeof(sa));
sa.sa_handler = alarm_handler;
if (shmctl(shmid, IPC_RMID, 0) < 0)
perror("shmctl IPC_RMID");
- return 0;
+ return EXIT_SUCCESS;
}
if ((lenpath = GetModuleFileName(NULL, ServicePath, 512)) == 0) {
fprintf(stderr, "Can't get executable path\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
snprintf(szPath, sizeof(szPath), "%s %s:" SQUIDSBUFPH, ServicePath, _WIN_SQUID_SERVICE_OPTION, SQUIDSBUFPRINT(service_name));
if (!schSCManager) {
fprintf(stderr, "OpenSCManager failed\n");
- exit(1);
+ exit(EXIT_FAILURE);
} else {
schService = CreateService(schSCManager, /* SCManager database */
service, /* name of service */
printf("Don't forget to edit squid.conf before starting it.\n\n");
} else {
fprintf(stderr, "CreateService failed\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
CloseServiceHandle(schSCManager);
if (!schSCManager) {
fprintf(stderr, "OpenSCManager failed\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/* The required service object access depends on the control. */
break;
default:
- exit(1);
+ exit(EXIT_FAILURE);
}
/* Open a handle to the service. */
if (schService == NULL) {
fprintf(stderr, "%s: ERROR: Could not open Service " SQUIDSBUFPH "\n", APP_SHORTNAME, SQUIDSBUFPRINT(service_name));
- exit(1);
+ exit(EXIT_FAILURE);
} else {
/* Send a control value to the service. */
&ssStatus)) { /* address of status info */
fprintf(stderr, "%s: ERROR: Could not Control Service " SQUIDSBUFPH "\n",
APP_SHORTNAME, SQUIDSBUFPRINT(service_name));
- exit(1);
+ exit(EXIT_FAILURE);
} else {
/* Print the service status. */
printf("\nStatus of " SQUIDSBUFPH " Service:\n", SQUIDSBUFPRINT(service_name));
if (FAILED(hr)) {
debug("My_NameTranslate: cannot initialize COM interface, ERROR: %s\n", Get_WIN32_ErrorMessage(hr));
/* This is a fatal error */
- exit(1);
+ exit(EXIT_FAILURE);
}
WIN32_COM_initialized = 1;
}
if (FAILED(hr)) {
debug("My_NameTranslate: cannot create COM instance, ERROR: %s\n", Get_WIN32_ErrorMessage(hr));
/* This is a fatal error */
- exit(1);
+ exit(EXIT_FAILURE);
}
hr = pNto->lpVtbl->Init(pNto, ADS_NAME_INITTYPE_GC, L"");
if (FAILED(hr)) {
debug("My_NameTranslate: cannot initialise NameTranslate API, ERROR: %s\n", Get_WIN32_ErrorMessage(hr));
pNto->lpVtbl->Release(pNto);
/* This is a fatal error */
- exit(1);
+ exit(EXIT_FAILURE);
}
hr = pNto->lpVtbl->Set(pNto, in_format, name);
if (FAILED(hr)) {
break;
case 'h':
usage(argv[0]);
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
default:
fprintf(stderr, "%s: FATAL: Unknown option: -%c. Exiting\n", program_name, opt);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
break; /* not reached */
}
}
- return;
}
int
if (use_global) {
if ((machinedomain = GetDomainName()) == NULL) {
fprintf(stderr, "%s: FATAL: Can't read machine domain\n", program_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
strlwr(machinedomain);
if (!DefaultDomain)
}
err = 0;
}
- return 0;
+ return EXIT_SUCCESS;
}
case 'H':
#if !HAS_URI_SUPPORT
fprintf(stderr, "FATAL: Your LDAP library does not have URI support\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
/* Fall thru to -h */
case 'h':
searchscope = LDAP_SCOPE_SUBTREE;
else {
fprintf(stderr, PROGRAM_NAME ": FATAL: Unknown search scope '%s'\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'E':
port = LDAPS_PORT;
#else
fprintf(stderr, PROGRAM_NAME ": FATAL: -E unsupported with this LDAP library\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
break;
case 'c':
aliasderef = LDAP_DEREF_FINDING;
else {
fprintf(stderr, PROGRAM_NAME ": FATAL: Unknown alias dereference method '%s'\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'D':
break;
default:
fprintf(stderr, "FATAL: Protocol version should be 2 or 3\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'Z':
if (version == LDAP_VERSION2) {
fprintf(stderr, "FATAL: TLS (-Z) is incompatible with version %d\n",
version);
- exit(1);
+ exit(EXIT_FAILURE);
}
version = LDAP_VERSION3;
use_tls = 1;
break;
default:
fprintf(stderr, PROGRAM_NAME ": FATAL: Unknown command line option '%c'\n", option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, "\t-d\t\t\tenable debug mode\n");
fprintf(stderr, "\n");
fprintf(stderr, "\tIf you need to bind as a user to perform searches then use the\n\t-D binddn -w bindpasswd or -D binddn -W secretfile options\n\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/* On Windows ldap_start_tls_s is available starting from Windows XP,
* so we need to bind at run-time with the function entry point
WLDAP32Handle = GetModuleHandle("wldap32");
if ((Win32_ldap_start_tls_s = (PFldap_start_tls_s) GetProcAddress(WLDAP32Handle, LDAP_START_TLS_S)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": FATAL: TLS (-Z) not supported on this platform.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
}
#endif
if (sslpath) {
if (!sslinit && (ldapssl_client_init(sslpath, NULL) != LDAP_SUCCESS)) {
fprintf(stderr, "FATAL: Unable to initialise SSL with cert path %s\n", sslpath);
- exit(1);
+ exit(EXIT_FAILURE);
} else {
++sslinit;
}
if ((ld = ldapssl_init(ldapServer, port, 1)) == NULL) {
fprintf(stderr, "FATAL: Unable to connect to SSL LDAP server: %s port:%d\n",
ldapServer, port);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else
#endif
#ifdef LDAP_OPT_X_TLS
if (version != LDAP_VERSION3) {
fprintf(stderr, "FATAL: TLS requires LDAP version 3\n");
- exit(1);
+ exit(EXIT_FAILURE);
} else if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) {
broken = HLP_MSG("Could not Activate TLS connection");
fprintf(stderr, "ERROR: %s\n", broken);
}
#else
fprintf(stderr, "FATAL: TLS not supported with your LDAP library\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
}
#endif
}
if (ld)
ldap_unbind(ld);
- return 0;
+ return EXIT_SUCCESS;
}
static std::string
break;
case 'h':
usage(argv[0]);
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
default:
fprintf(stderr, "%s: FATAL: Unknown option: -%c. Exiting\n", program_name, opt);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
break; /* not reached */
}
}
if (use_global) {
if ((machinedomain = GetDomainName()) == NULL) {
fprintf(stderr, "%s: FATAL: Can't read machine domain\n", program_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
strlwr(machinedomain);
if (!DefaultDomain)
SEND_ERR("");
}
}
- return 0;
+ return EXIT_SUCCESS;
}
CloseLDAP(&edui_ldap);
debug("Terminating, Signal: %d\n", s);
- exit(0);
+ exit(EXIT_SUCCESS);
}
/*
break;
case 'h':
usage(program_name);
- exit (0);
+ exit(EXIT_SUCCESS);
default:
fprintf(stderr, "%s: FATAL: Unknown parameter option '%c'", program_name, ch);
usage(program_name);
- exit (1);
+ exit(EXIT_FAILURE);
}
}
if (filename == NULL) {
fprintf(stderr, "%s: FATAL: No Filename configured.", program_name);
usage(program_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
FILE *FH = fopen(filename, "r");
if (!FH) {
int xerrno = errno;
fprintf(stderr, "%s: FATAL: Unable to open file '%s': %s", program_name, filename, xstrerr(xerrno));
- exit(1);
+ exit(EXIT_FAILURE);
}
current_entry = load_dict(FH);
}
fclose (FH);
- return 0;
+ return EXIT_SUCCESS;
}
fprintf(stderr, "server@domain - In this case server can be used for Kerberos domain domain\n");
fprintf(stderr, "server1a@domain1:server1b@domain1:server2@domain2:server3@:server4 - A list is build with a colon as separator\n");
clean_args(&margs);
- exit(0);
+ exit(EXIT_SUCCESS);
default:
warn((char *) "%s| %s: WARNING: unknown option: -%c.\n", LogTime(), PROGRAM, opt);
}
debug((char *) "%s| %s: FATAL: Error in group list: %s\n", LogTime(), PROGRAM, margs.glist ? margs.glist : "NULL");
SEND_BH("");
clean_args(&margs);
- exit(1);
+ exit(EXIT_FAILURE);
} else {
debug((char *) "%s| %s: INFO: no group list given expect it from stdin\n", LogTime(), PROGRAM);
gopt = 1;
debug((char *) "%s| %s: FATAL: Error in netbios list: %s\n", LogTime(), PROGRAM, margs.nlist ? margs.nlist : "NULL");
SEND_BH("");
clean_args(&margs);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (create_ls(&margs)) {
debug((char *) "%s| %s: Error in ldap server list: %s\n", LogTime(), PROGRAM, margs.llist ? margs.llist : "NULL");
SEND_BH("");
clean_args(&margs);
- exit(1);
+ exit(EXIT_FAILURE);
}
#if HAVE_KRB5
error((char *) "%s| %s: ERROR: Error while initialising Kerberos library : %s\n", LogTime(), PROGRAM, error_message(code));
SEND_BH("");
clean_args(&margs);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
#if HAVE_KRB5
krb5_cleanup();
#endif
- exit(1); /* BIIG buffer */
+ exit(EXIT_FAILURE); /* BIIG buffer */
}
SEND_BH("fgets NULL");
clean_args(&margs);
#if HAVE_KRB5
krb5_cleanup();
#endif
- exit(0);
+ exit(EXIT_SUCCESS);
}
c = (char *) memchr(buf, '\n', sizeof(buf) - 1);
if (c) {
krb5_cleanup();
#endif
- exit(-1);
+ exit(EXIT_SUCCESS);
}
if (gopt) {
if ((group = strtok(NULL, " \n")) != NULL) {
fprintf(stdout, "ERR\n");
fprintf(stderr, "LDAP group authorisation not supported\n");
}
+ return EXIT_SUCCESS
}
#endif
if (db_env->open(db_env, db_path, DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK , 0666)) {
fprintf(stderr, "FATAL: %s: Failed to open database environment in '%s'\n", program_name, db_path);
db_env->close(db_env, 0);
- exit(1);
+ exit(EXIT_FAILURE);
}
db_create(&db, db_env, 0);
}
fprintf(stderr, "FATAL: %s: Failed to open db file '%s' in dir '%s'\n",
program_name, "session", db_path);
db_env->close(db_env, 0);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else {
db_create(&db, NULL, 0);
if (db->open(db, NULL, db_path, NULL, DB_BTREE, DB_CREATE, 0666)) {
fprintf(stderr, "FATAL: %s: Failed to open session db '%s'\n", program_name, db_path);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
}
break;
case '?':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
break;
}
}
// Only 1 paramater supplied. We are expecting at least 2 (including the channel ID)
fprintf(stderr, "FATAL: %s is concurrent and requires the concurrency option to be specified.\n", program_name);
shutdown_db();
- exit(1);
+ exit(EXIT_FAILURE);
}
char *lastdetail = strrchr(detail, ' ');
size_t detail_len = strlen(detail);
}
}
shutdown_db();
- return 0;
+ return EXIT_SUCCESS;
}
db = dbopen(db_path, O_CREAT | O_RDWR, 0666, DB_BTREE, NULL);
if (!db) {
log_fatal("Failed to open time_quota db '%s'\n", db_path);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
break;
}
}
if ( optind + 1 != argc ) {
usage();
- exit(1);
+ exit(EXIT_FAILURE);
} else {
readConfig(argv[optind]);
}
}
log_info("Ending %s\n", __FILE__);
shutdown_db();
- return 0;
+ return EXIT_SUCCESS;
}
default:
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (optind < argc) {
fprintf(stderr, "FATAL: Unknown option '%s'\n", argv[optind]);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
while (fgets(buf, HELPER_INPUT_BUFFER, stdin)) {
j = 0;
SEND_ERR("");
}
}
- return 0;
+ return EXIT_SUCCESS;
}
int rc = ldap_initialize(&ld, ldapServer);
if (rc != LDAP_SUCCESS) {
fprintf(stderr, "\nUnable to connect to LDAPURI:%s\n", ldapServer);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else
#endif
if (!sslinit && (ldapssl_client_init(sslpath, NULL) != LDAP_SUCCESS)) {
fprintf(stderr, "\nUnable to initialise SSL with cert path %s\n",
sslpath);
- exit(1);
+ exit(EXIT_FAILURE);
} else {
++sslinit;
}
if ((ld = ldapssl_init(ldapServer, port, 1)) == NULL) {
fprintf(stderr, "\nUnable to connect to SSL LDAP server: %s port:%d\n",
ldapServer, port);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else
#endif
if ((ld = ldap_init(ldapServer, port)) == NULL) {
fprintf(stderr, "\nUnable to connect to LDAP server:%s port:%d\n",
ldapServer, port);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (connect_timeout)
squid_ldap_set_connect_timeout(ld, connect_timeout);
if (ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &version) != LDAP_SUCCESS) {
fprintf(stderr, "Could not set LDAP_OPT_PROTOCOL_VERSION %d\n",
version);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (use_tls) {
#ifdef LDAP_OPT_X_TLS
if (version != LDAP_VERSION3) {
fprintf(stderr, "TLS requires LDAP version 3\n");
- exit(1);
+ exit(EXIT_FAILURE);
} else if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) {
fprintf(stderr, "Could not Activate TLS connection\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
#else
fprintf(stderr, "TLS not supported with your LDAP library\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
}
#endif
case 'H':
#if !HAS_URI_SUPPORT
fprintf(stderr, "ERROR: Your LDAP library does not have URI support\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
/* Fall thru to -h */
case 'h':
searchscope = LDAP_SCOPE_SUBTREE;
else {
fprintf(stderr, PROGRAM_NAME ": ERROR: Unknown search scope '%s'\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'E':
port = LDAPS_PORT;
#else
fprintf(stderr, PROGRAM_NAME " ERROR: -E unsupported with this LDAP library\n");
- exit(1);
+ exit(EXIT_FAILURE);
#endif
break;
case 'c':
aliasderef = LDAP_DEREF_FINDING;
else {
fprintf(stderr, PROGRAM_NAME ": ERROR: Unknown alias dereference method '%s'\n", value);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'D':
break;
default:
fprintf(stderr, "Protocol version should be 2 or 3\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'Z':
if (version == LDAP_VERSION2) {
fprintf(stderr, "TLS (-Z) is incompatible with version %d\n",
version);
- exit(1);
+ exit(EXIT_FAILURE);
}
version = LDAP_VERSION3;
use_tls = 1;
break;
default:
fprintf(stderr, PROGRAM_NAME ": ERROR: Unknown command line option '%c'\n", option);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
fprintf(stderr, "\n");
fprintf(stderr, "\tIf no search filter is specified, then the dn <userattr>=user,basedn\n\twill be used (same as specifying a search filter of '<userattr>=',\n\tbut quicker as as there is no need to search for the user DN)\n\n");
fprintf(stderr, "\tIf you need to bind as a user to perform searches then use the\n\t-D binddn -w bindpasswd or -D binddn -W secretfile options\n\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/* On Windows ldap_start_tls_s is available starting from Windows XP,
* so we need to bind at run-time with the function entry point
WLDAP32Handle = GetModuleHandle("wldap32");
if ((Win32_ldap_start_tls_s = (PFldap_start_tls_s) GetProcAddress(WLDAP32Handle, LDAP_START_TLS_S)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": ERROR: TLS (-Z) not supported on this platform.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
}
#endif
}
if (ld)
ldap_unbind(ld);
- return 0;
+ return EXIT_SUCCESS;
}
static int
passwd = (char *) calloc(sizeof(char), strlen(buf) + 1);
if (!passwd) {
fprintf(stderr, PROGRAM_NAME " ERROR: can not allocate memory\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
strcpy(passwd, buf);
bindpasswd = passwd;
if (!f) {
int xerrno = errno;
fprintf(stderr, "FATAL: %s: %s\n", passwdfile, xstrerr(xerrno));
- exit(1);
+ exit(EXIT_FAILURE);
}
unsigned int lineCount = 0;
buf[HELPER_INPUT_BUFFER-1] = '\0';
setbuf(stdout, NULL);
if (argc != 2) {
fprintf(stderr, "Usage: ncsa_auth <passwordfile>\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
if (stat(argv[1], &sb) != 0) {
fprintf(stderr, "FATAL: cannot stat %s\n", argv[1]);
- exit(1);
+ exit(EXIT_FAILURE);
}
while (fgets(buf, HELPER_INPUT_BUFFER, stdin) != NULL) {
if ((p = strchr(buf, '\n')) != NULL)
}
SEND_ERR("Wrong password");
}
- exit(0);
+ return EXIT_SUCCESS;
}
fprintf(stderr, "Usage: basic_nis_auth <domainname> <nis map for password>\n");
fprintf(stderr, "\n");
fprintf(stderr, "Example basic_nis_auth mydomain.com passwd.byname\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
nisdomain = argv[1];
nismap = argv[2];
printf("BH message=\"Missing crypto capability\"\n");
#endif
}
- exit(0);
+ return EXIT_SUCCESS;
}
default:
fprintf(stderr, "FATAL: Unknown getopt value '%c'\n", ch);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
start:
if (optind < argc) {
fprintf(stderr, "FATAL: Unknown option '%s'\n", argv[optind]);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
while (fgets(buf, HELPER_INPUT_BUFFER, stdin)) {
debug("ERROR: failed to release PAM authenticator\n");
}
}
- return 0;
+ return EXIT_SUCCESS;
}
}
/* make standard output line buffered */
if (setvbuf(stdout, NULL, _IOLBF, 0) != 0)
- return 1;
+ exit(EXIT_FAILURE);
if (cfname) {
if (rad_auth_config(cfname) < 0) {
fprintf(stderr, "FATAL: %s: can't open configuration file '%s'.\n", argv[0], cfname);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if (!*server) {
fprintf(stderr, "FATAL: %s: Server not specified\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
if (!*secretkey) {
fprintf(stderr, "FATAL: %s: Shared secret not specified\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
#if _SQUID_WINDOWS_
{
/* Get the IP address of the authentication server */
if ((auth_ipaddr = get_ipaddr(server)) == 0) {
fprintf(stderr, "FATAL: %s: Couldn't find host %s\n", argv[0], server);
- exit(1);
+ exit(EXIT_FAILURE);
}
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("socket");
- exit(1);
+ exit(EXIT_FAILURE);
}
memset(&saremote, 0, sizeof(saremote));
saremote.sin_family = AF_INET;
if (connect(sockfd, (struct sockaddr *) &saremote, sizeof(saremote)) < 0) {
perror("connect");
- exit(1);
+ exit(EXIT_FAILURE);
}
salen = sizeof(salocal);
if (getsockname(sockfd, (struct sockaddr *) &salocal, &salen) < 0) {
perror("getsockname");
- exit(1);
+ exit(EXIT_FAILURE);
}
#ifdef O_NONBLOCK
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK) < 0) {
int xerrno = errno;
fprintf(stderr,"%s| ERROR: fcntl() failure: %s\n", argv[0], xstrerr(xerrno));
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
nas_ipaddr = ntohl(salocal.sin_addr.s_addr);
authenticate(sockfd, username, passwd);
}
close(sockfd);
- exit(1);
+ return EXIT_SUCCESS;
}
if ( rc != SASL_OK ) {
fprintf(stderr, "FATAL: %d %s\n", rc, sasl_errstring(rc, NULL, NULL ));
- return 1;
+ exit(EXIT_FAILURE);
}
#if SASL_VERSION_MAJOR < 2
if ( rc != SASL_OK ) {
fprintf(stderr, "FATAL: %d %s\n", rc, sasl_errstring(rc, NULL, NULL ));
- return 1;
+ exit(EXIT_FAILURE);
}
while ( fgets( line, HELPER_INPUT_BUFFER, stdin )) {
sasl_dispose(&conn);
sasl_done();
- return 0;
+ return EXIT_SUCCESS;
}
/* make standard output line buffered */
if (setvbuf(stdout, NULL, _IOLBF, 0) != 0)
- return 1;
+ exit(EXIT_FAILURE);
/* parse command line arguments */
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "-S") == 0) {
if (lastdom != NULL) {
if ((lastdom->authshare = xstrdup(argv[++i])) == NULL)
- return 1;
+ exit(EXIT_FAILURE);
/* convert backslashes to forward slashes */
for (s = lastdom->authshare; *s != '\0'; ++s)
else
SEND_ERR("");
} /* while (1) */
- return 0;
+
+ return EXIT_SUCCESS;
}
if (dc.domain.length() == 0 || dc.server.length() == 0) {
std::cerr << "Error: invalid domain specification in '" << arg <<
"'. Ignoring." << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
domaincontrollers.push_back(dc);
}
if (domaincontrollers.empty()) {
display_usage_instructions();
std::cerr << "Error: no domain controllers specified" << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
while (1) {
err = 0;
}
- return 0;
+ return EXIT_SUCCESS;
}
break;
case 'h':
usage(argv[0]);
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
default:
fprintf(stderr, "FATAL: Unknown option: -%c\n", opt);
usage(argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
}
if (LoadSecurityDll(SSP_BASIC, NTLM_PACKAGE_NAME) == NULL) {
fprintf(stderr, "FATAL: can't initialize SSPI, exiting.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
debug("SSPI initialized OK\n");
err = 0;
fflush(stdout);
}
- return 0;
+ return EXIT_SUCCESS;
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
default:
std::cerr << program_name << ": FATAL: unknown option: -" <<
static_cast<char>(optopt) << ". Exiting" << std::endl;
usage();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
}
}
ndebug(program_name << ' ' << VERSION << ' ' << SQUID_BUILD_INFO <<
" shutting down...");
- return 0;
+ return EXIT_SUCCESS;
}
}
}
}
- return 0;
+ return EXIT_SUCCESS;
}
static void
ProcessArguments(int argc, char **argv)
{
- int i;
- i = LDAPArguments(argc, argv);
- if (i)
+ if (int i = LDAPArguments(argc, argv))
exit(i);
}
ProcessArguments(argc, argv);
while (fgets(buf, HELPER_INPUT_BUFFER, stdin) != NULL)
DoOneRequest(buf);
- exit(0);
+ return EXIT_SUCCESS;
}
WLDAP32Handle = GetModuleHandle("wldap32");
if ((Win32_ldap_start_tls_s = (PFldap_start_tls_s) GetProcAddress(WLDAP32Handle, LDAP_START_TLS_S)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": ERROR: TLS (-Z) not supported on this platform.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
}
#endif
if (!sslinit && (ldapssl_client_init(sslpath, NULL) != LDAP_SUCCESS)) {
fprintf(stderr, "\nUnable to initialise SSL with cert path %s\n",
sslpath);
- exit(1);
+ exit(EXIT_FAILURE);
} else {
++sslinit;
}
if ((ld = ldapssl_init(ldapServer, port, 1)) == NULL) {
fprintf(stderr, "\nUnable to connect to SSL LDAP server: %s port:%d\n",
ldapServer, port);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else
#endif
#ifdef LDAP_OPT_X_TLS
if (version != LDAP_VERSION3) {
fprintf(stderr, "TLS requires LDAP version 3\n");
- exit(1);
+ exit(EXIT_FAILURE);
} else if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) {
fprintf(stderr, "Could not Activate TLS connection\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
#else
fprintf(stderr, "TLS not supported with your LDAP library\n");
static void
ProcessArguments(int argc, char **argv)
{
- int i;
- i = LDAPArguments(argc, argv);
- if (i)
+ if (int i = LDAPArguments(argc, argv))
exit(i);
}
ProcessArguments(argc, argv);
while (fgets(buf, HELPER_INPUT_BUFFER, stdin) != NULL)
DoOneRequest(buf);
- exit(0);
+ return EXIT_SUCCESS;
}
WLDAP32Handle = GetModuleHandle("wldap32");
if ((Win32_ldap_start_tls_s = (PFldap_start_tls_s) GetProcAddress(WLDAP32Handle, LDAP_START_TLS_S)) == NULL) {
fprintf(stderr, PROGRAM_NAME ": ERROR: TLS (-Z) not supported on this platform.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
}
#endif
if (!sslinit && (ldapssl_client_init(sslpath, NULL) != LDAP_SUCCESS)) {
fprintf(stderr, "\nUnable to initialise SSL with cert path %s\n",
sslpath);
- exit(1);
+ exit(EXIT_FAILURE);
} else {
++sslinit;
}
if ((ld = ldapssl_init(ldapServer, port, 1)) == NULL) {
fprintf(stderr, "\nUnable to connect to SSL LDAP server: %s port:%d\n",
ldapServer, port);
- exit(1);
+ exit(EXIT_FAILURE);
}
} else
#endif
ProcessArguments(argc, argv);
while (fgets(buf, HELPER_INPUT_BUFFER, stdin) != NULL)
DoOneRequest(buf);
- return 0;
+ return EXIT_SUCCESS;
}
hash = hash_create((HASHCMP *) strcmp, 7921, hash_string);
if (NULL == hash) {
fprintf(stderr, "digest_file_auth: cannot create hash table\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
FILE *f = fopen(passwordFile, "r");
if (!f) {
int xerrno = errno;
fprintf(stderr, "digest_file_auth: cannot open password file: %s\n", xstrerr(xerrno));
- exit(1);
+ exit(EXIT_FAILURE);
}
unsigned int lineCount = 0;
while (fgets(buf, sizeof(buf), f) != NULL) {
if (!passwdfile) {
fprintf(stderr, "Usage: digest_file_auth [OPTIONS] <passwordfile>\n");
fprintf(stderr, " -c accept digest hashed passwords rather than plaintext in passwordfile\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
if (stat(passwdfile, &sb) != 0) {
fprintf(stderr, "cannot stat %s\n", passwdfile);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
}
}
if (had_error)
- exit(1);
+ exit(EXIT_FAILURE);
}
static bool
if (LoadSecurityDll(SSP_NTLM, NEGOTIATE_PACKAGE_NAME) == NULL) {
fprintf(stderr, "FATAL: %s: can't initialize SSPI, exiting.\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
debug("SSPI initialized OK\n");
while (manage_request()) {
/* everything is done within manage_request */
}
- exit(0);
+ return EXIT_SUCCESS;
}
keytab_name = xstrdup(optarg);
else {
fprintf(stderr, "ERROR: keytab file not given\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/*
* Some sanity checks
fprintf(stderr, "ERROR: keytab file %s does not exist\n",keytab_name);
else
fprintf(stderr, "ERROR: Error %s during stat of keytab file %s\n",strerror(errno),keytab_name);
- exit(1);
+ exit(EXIT_FAILURE);
} else if (!S_ISREG(fstat.st_mode)) {
fprintf(stderr, "ERROR: keytab file %s is not a file\n",keytab_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
#if HAVE_UNISTD_H
if (access(ktp, R_OK)) {
fprintf(stderr, "ERROR: keytab file %s is not accessible\n",keytab_name);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
break;
rcache_dir = xstrdup(optarg);
else {
fprintf(stderr, "ERROR: replay cache directory not given\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
/*
* Some sanity checks
fprintf(stderr, "ERROR: replay cache directory %s does not exist\n",rcache_dir);
else
fprintf(stderr, "ERROR: Error %s during stat of replay cache directory %s\n",strerror(errno),rcache_dir);
- exit(1);
+ exit(EXIT_FAILURE);
} else if (!S_ISDIR(dstat.st_mode)) {
fprintf(stderr, "ERROR: replay cache directory %s is not a directory\n",rcache_dir);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
#if HAVE_UNISTD_H
if (access(rcache_dir, W_OK)) {
fprintf(stderr, "ERROR: replay cache directory %s is not accessible\n",rcache_dir);
- exit(1);
+ exit(EXIT_FAILURE);
}
#endif
break;
rcache_type = xstrdup(optarg);
else {
fprintf(stderr, "ERROR: replay cache type not given\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 's':
service_principal = xstrdup(optarg);
else {
fprintf(stderr, "ERROR: service principal not given\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
default:
fprintf(stderr,
"The SPN can be set to GSS_C_NO_NAME to allow any entry from keytab\n");
fprintf(stderr, "default SPN is HTTP/fqdn@DEFAULT_REALM\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
}
"%s| %s: FATAL: Local hostname could not be determined. Please specify the service principal\n",
LogTime(), PROGRAM);
fprintf(stdout, "BH hostname error\n");
- exit(-1);
+ exit(EXIT_FAILURE);
}
service.value = xmalloc(strlen(service_name) + strlen(host_name) + 2);
snprintf((char *) service.value, strlen(service_name) + strlen(host_name) + 2,
strerror(ferror(stdin)));
fprintf(stdout, "BH input error\n");
- exit(1); /* BIIG buffer */
+ exit(EXIT_FAILURE); /* BIIG buffer */
}
fprintf(stdout, "BH input error\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
c = (char *) memchr(buf, '\n', sizeof(buf) - 1);
if (c) {
}
xfree(token);
fprintf(stdout, "BH quit command\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
if (strncmp(buf, "YR", 2) && strncmp(buf, "KK", 2)) {
debug((char *) "%s| %s: ERROR: Invalid request [%s]\n", LogTime(), PROGRAM, buf);
safe_free(user);
continue;
}
+ return EXIT_SUCCESS;
}
#else
#include <cstdlib>
while (1) {
if (fgets(buf, sizeof(buf) - 1, stdin) == NULL) {
fprintf(stdout, "BH input error\n");
- exit(0);
+ exit(EXIT_SUCCESS);
}
fprintf(stdout, "BH Kerberos authentication not supported\n");
}
+ return EXIT_SUCCESS;
}
#endif /* HAVE_GSSAPI */
fprintf(stdout, "Token: %s\n", Token ? Token : "NULL");
}
- return 0;
+ return EXIT_SUCCESS;
}
#else
if (argc ==1 || !strncasecmp(argv[1],"-h",2)) {
usage();
- return 0;
+ exit(EXIT_SUCCESS);
}
int j = 1;
}
if (nstart == 0 || kstart == 0 || kend-kstart <= 0 || nend-nstart <= 0 ) {
usage();
- return 0;
+ exit(EXIT_SUCCESS);
}
if (debug_enabled)
if ((nargs = (char **)xmalloc((nend-nstart+1)*sizeof(char *))) == NULL) {
fprintf(stderr, "%s| %s: Error allocating memory for ntlm helper\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
memcpy(nargs,argv+nstart+1,(nend-nstart)*sizeof(char *));
nargs[nend-nstart]=NULL;
}
if ((kargs = (char **)xmalloc((kend-kstart+1)*sizeof(char *))) == NULL) {
fprintf(stderr, "%s| %s: Error allocating memory for kerberos helper\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
memcpy(kargs,argv+kstart+1,(kend-kstart)*sizeof(char *));
kargs[kend-kstart]=NULL;
if (pipe(pkin) < 0) {
fprintf(stderr, "%s| %s: Could not assign streams for pkin\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if (pipe(pkout) < 0) {
fprintf(stderr, "%s| %s: Could not assign streams for pkout\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if (( fpid = vfork()) < 0 ) {
fprintf(stderr, "%s| %s: Failed first fork\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if ( fpid == 0 ) {
execv(kargs[0], kargs);
fprintf(stderr, "%s| %s: Failed execv for %s: %s\n", LogTime(), PROGRAM, kargs[0], strerror(errno));
- return 1;
+ exit(EXIT_FAILURE);
}
close(pkin[0]);
if (pipe(pnin) < 0) {
fprintf(stderr, "%s| %s: Could not assign streams for pnin\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if (pipe(pnout) < 0) {
fprintf(stderr, "%s| %s: Could not assign streams for pnout\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if (( fpid = vfork()) < 0 ) {
fprintf(stderr, "%s| %s: Failed second fork\n", LogTime(), PROGRAM);
- return 1;
+ exit(EXIT_FAILURE);
}
if ( fpid == 0 ) {
execv(nargs[0], nargs);
fprintf(stderr, "%s| %s: Failed execv for %s: %s\n", LogTime(), PROGRAM, nargs[0], strerror(errno));
- return 1;
+ exit(EXIT_FAILURE);
}
close(pnin[0]);
if (!FDKIN || !FDKOUT || !FDNIN || !FDNOUT) {
fprintf(stderr, "%s| %s: Could not assign streams for FDKIN/FDKOUT/FDNIN/FDNOUT\n", LogTime(), PROGRAM);
closeFds(FDKIN, FDKOUT, FDNIN, FDNOUT);
- return 1;
+ exit(EXIT_FAILURE);
}
setbuf(FDKIN, NULL);
}
}
if (had_error)
- exit(1);
+ exit(EXIT_FAILURE);
/* Okay, now begin filling controllers up */
/* we can avoid memcpy-ing, and just reuse argv[] */
for (j = optind; j < argc; ++j) {
if (numcontrollers == 0) {
fprintf(stderr, "You must specify at least one domain-controller!\n");
usage();
- exit(1);
+ exit(EXIT_FAILURE);
}
last_dc->next = controllers; /* close the queue, now it's circular */
}
if (fgets(buf, NTLM_BLOB_BUFFER_SIZE, stdin) == NULL) {
fprintf(stderr, "fgets() failed! dying..... errno=%d (%s)\n", errno,
strerror(errno));
- exit(1); /* BIIG buffer */
+ exit(EXIT_FAILURE); /* BIIG buffer */
}
debug("managing request\n");
ch2 = (char*)memchr(buf, '\n', NTLM_BLOB_BUFFER_SIZE); /* safer against overrun than strchr */
manage_request();
}
/* notreached */
- return 0;
+ return EXIT_SUCCESS;
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
}
}
if (had_error)
- exit(1);
+ exit(EXIT_FAILURE);
}
static bool
if (LoadSecurityDll(SSP_NTLM, NTLM_PACKAGE_NAME) == NULL) {
fprintf(stderr, "FATAL, can't initialize SSPI, exiting.\n");
- exit(1);
+ exit(EXIT_FAILURE);
}
debug("SSPI initialized OK\n");
while (manage_request()) {
/* everything is done within manage_request */
}
- exit(0);
+ return EXIT_SUCCESS;
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
}
}
if (had_error)
- exit(1);
+ exit(EXIT_FAILURE);
}
int
}
}
}
- exit(0);
+ return EXIT_SUCCESS;
}
{
fprintf(stderr, "usage: %s <label1>: <swap_state>... <label2>: <swap_state>...\n",
prg_name);
- return -1;
+ return EXIT_FAILURE;
}
int
cacheIndexDestroy(CacheIdx[1]);
- return 1;
+ return EXIT_FAILURE;
}
}
if (entry == entries.end()) {
std::cerr << "ERROR: '" << directive << "' (" << name << ") depends on '" << *dep << "'\n";
- exit(1);
+ exit(EXIT_FAILURE);
}
}
return;
}
std::cerr << "ERROR: Dependencies for cf.data type '" << name << "' used in ' " << directive << "' not defined\n" ;
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
usage(const char *program_name)
{
std::cerr << "Usage: " << program_name << " cf.data cf.data.depend\n";
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
if (fp.fail()) {
std::cerr << "Error while opening type dependencies file '" <<
type_depend << "': " << strerror(errno) << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
while (fp.good()) {
if (fp.fail()) {
std::cerr << "Error while opening input file '" <<
input_filename << "': " << strerror(errno) << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
state = sSTART;
if (strncmp(buff, "IF ", 3) == 0) {
if ((ptr = strtok(buff + 3, WS)) == NULL) {
errorMsg(input_filename, linenum, "Missing IF parameter");
- exit(1);
+ exit(EXIT_FAILURE);
}
IFDEFS.push(ptr);
continue;
} else if (strcmp(buff, "ENDIF") == 0) {
if (IFDEFS.size() == 0) {
errorMsg(input_filename, linenum, "ENDIF without IF first");
- exit(1);
+ exit(EXIT_FAILURE);
}
IFDEFS.pop();
} else if (!IFDEFS.size() || isDefined(IFDEFS.top()))
if ((name = strtok(buff + 5, WS)) == NULL) {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
entries.push_back(name);
state = sDOC;
} else {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
} else if (!strncmp(buff, "LOC:", 4)) {
if ((ptr = strtok(buff + 4, WS)) == NULL) {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
curr.loc = ptr;
} else if (!strncmp(buff, "TYPE:", 5)) {
if ((ptr = strtok(buff + 5, WS)) == NULL) {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
/* hack to support arrays, rather than pointers */
} else if (!strncmp(buff, "IFDEF:", 6)) {
if ((ptr = strtok(buff + 6, WS)) == NULL) {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
curr.ifdef = ptr;
state = sSTART;
} else {
errorMsg(input_filename, linenum, buff);
- exit(1);
+ exit(EXIT_FAILURE);
}
}
break;
if (state != sEXIT) {
errorMsg(input_filename, linenum, "Error: unexpected EOF");
- exit(1);
+ exit(EXIT_FAILURE);
}
fp.close();
if (!fout.good()) {
std::cerr << "Error while opening output .c file '" <<
output_filename << "': " << strerror(errno) << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
fout << "/*\n" <<
if (!fout.good()) {
std::cerr << "Error while opening output conf file '" <<
output_filename << "': " << strerror(errno) << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
gen_conf(entries, fout, 1);
if (!fout.good()) {
std::cerr << "Error while opening output short conf file '" <<
output_filename << "': " << strerror(errno) << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
gen_conf(entries, fout, 0);
fout.close();
if (!entry->defaults.preset.empty()) {
std::cerr << "ERROR: " << entry->name << " has preset defaults. DEFAULT_IF_NONE cannot be true." << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
if (entry->ifdef.size())
}
fprintf(stderr, "unknown syslog facility '%s'\n", facility);
- exit(1);
+ exit(EXIT_FAILURE);
}
#else
struct sockaddr_in S;
if (3 != argc) {
fprintf(stderr, "usage: %s ip port\n", argv[0]);
- return 1;
+ exit(EXIT_FAILURE);
}
setbuf(stdout, NULL);
setbuf(stderr, NULL);
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s < 0) {
perror("socket");
- return 1;
+ exit(EXIT_FAILURE);
}
memset(&S, '\0', sizeof(S));
S.sin_family = AF_INET;
}
}
}
- return 0;
+ return EXIT_SUCCESS;
}
#endif
if ( argc < 3 || argc > 4) {
fprintf(stderr, "usage: %s [-6|-4] ip port\n", argv[0]);
- return 1;
+ exit(EXIT_FAILURE);
}
setbuf(stdout, NULL);
else {
fprintf(stderr, "usage: %s [-6|-4] [-E packet-size] ip port\n", argv[0]);
fprintf(stderr, " EDNS packets my be up to %d\n", PACKET_BUFSZ);
- return 1;
+ exit(EXIT_FAILURE);
}
var++;
if (s < 0) {
perror("socket");
- return 1;
+ exit(EXIT_FAILURE);
}
memset(&S, '\0', sizeof(S));
if ( ! inet_pton(AF_INET6, argv[var], &((struct sockaddr_in6 *)S)->sin6_addr.s_addr) ) {
perror("listen address");
- return 1;
+ exit(EXIT_FAILURE);
}
s = socket(PF_INET6, SOCK_DGRAM, 0);
((struct sockaddr_in *)S)->sin_family = AF_INET;
((struct sockaddr_in *)S)->sin_port = htons(atoi(argv[var+1]));
- if ( ! inet_pton(AF_INET, argv[var], &((struct sockaddr_in *)S)->sin_addr.s_addr) )
+ if ( ! inet_pton(AF_INET, argv[var], &((struct sockaddr_in *)S)->sin_addr.s_addr) ) {
perror("listen address");
- return 1;
+ exit(EXIT_FAILURE);
}
}
}
}
-return 0;
+return EXIT_SUCCESS;
}
#endif
fatal_common(message);
- exit(1);
+ exit(EXIT_FAILURE);
}
/* used by fatalf */
/* make standard output line buffered */
if (setvbuf(stdout, NULL, _IOLBF, 0) != 0)
- return 1;
+ exit(EXIT_FAILURE);
/* speed up the access() calls below */
if (chdir(ACCESS_LOCAL_DIR) == -1)
- return 1;
+ exit(EXIT_FAILURE);
/* scan standard input */
while (fgets(buf, BUFFER_SIZE, stdin) != NULL) {
(void) printf("\n");
}
- return 0;
+ return EXIT_SUCCESS;
}
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
case '?':
opt = optopt;
/* fall thru to default */
}
}
if (had_error)
- exit(1);
+ exit(EXIT_FAILURE);
}
int
}
}
debug("%s " VERSION " " SQUID_BUILD_INFO " shutting down...\n", my_program_name);
- return 0;
+ return EXIT_SUCCESS;
}
if (n < 0) {
debugs(42, DBG_IMPORTANT, "Pinger exiting.");
Close();
- exit(1);
+ exit(EXIT_FAILURE);
}
if (0 == n) {
debugs(42, DBG_CRITICAL, HERE << "EOF encountered. Pinger exiting.\n");
errno = 0;
Close();
- exit(1);
+ exit(EXIT_FAILURE);
}
guess_size = n - (sizeof(pingerEchoData) - PINGER_PAYLOAD_SZ);
int xerrno = errno;
debugs(42, DBG_CRITICAL, "pinger: FATAL error on send: " << xstrerr(xerrno));
Close();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
/** abort if neither worker could open a socket. */
if (icmp4_worker < 0 && icmp6_worker < 0) {
debugs(42, DBG_CRITICAL, "FATAL: pinger: Unable to open any ICMP sockets.");
- exit(1);
+ exit(EXIT_FAILURE);
}
if ( (squid_link = control.Open()) < 0) {
debugs(42, DBG_CRITICAL, "FATAL: pinger: Unable to setup Pinger control sockets.");
icmp4.Close();
icmp6.Close();
- exit(1); // fatal error if the control channel fails.
+ exit(EXIT_FAILURE); // fatal error if the control channel fails.
}
max_fd = max(max_fd, squid_link);
debugs(42, DBG_CRITICAL, "FATAL: pinger: setgid(" << getgid() << ") failed: " << xstrerr(xerrno));
icmp4.Close();
icmp6.Close();
- exit (1);
+ exit(EXIT_FAILURE);
}
if (setuid(getuid()) < 0) {
int xerrno = errno;
debugs(42, DBG_CRITICAL, "FATAL: pinger: setuid(" << getuid() << ") failed: " << xstrerr(xerrno));
icmp4.Close();
icmp6.Close();
- exit (1);
+ exit(EXIT_FAILURE);
}
#if USE_LIBCAP
debugs(42, DBG_CRITICAL, "FATAL: pinger: cap_init() failed: " << xstrerr(xerrno));
icmp4.Close();
icmp6.Close();
- exit (1);
+ exit(EXIT_FAILURE);
} else {
if (cap_set_proc(caps) != 0) {
int xerrno = errno;
cap_free(caps);
icmp4.Close();
icmp6.Close();
- exit (1);
+ exit(EXIT_FAILURE);
}
cap_free(caps);
}
int xerrno = errno;
debugs(42, DBG_CRITICAL, HERE << " FATAL Shutdown. select()==" << x << ", ERR: " << xstrerr(xerrno));
control.Close();
- exit(1);
+ exit(EXIT_FAILURE);
}
if (FD_ISSET(squid_link, &R)) {
if (send(LINK_TO_SQUID, &tv, 0, 0) < 0) {
debugs(42, DBG_CRITICAL, "pinger: Closing. No requests in last " << PINGER_TIMEOUT << " seconds.");
control.Close();
- exit(1);
+ exit(EXIT_FAILURE);
}
last_check_time = squid_curtime;
}
/* NOTREACHED */
- return 0;
+ return EXIT_SUCCESS;
}
#else /* !USE_ICMP */
main(int argc, char *argv[])
{
std::cerr << argv[0] << ": ICMP support not compiled in." << std::endl;
- return 1;
+ return EXIT_FAILURE;
}
#endif /* USE_ICMP */
if (argc < 2) {
printf("Error: usage: %s <logfile>\n", argv[0]);
- exit(1);
+ exit(EXIT_FAILURE);
}
fp = fopen(argv[1], "a");
if (fp == NULL) {
perror("fopen");
- exit(1);
+ exit(EXIT_FAILURE);
}
setbuf(stdout, NULL);
/* XXX stderr should not be closed, but in order to support squid must be
fp = fopen(argv[1], "a");
if (fp == NULL) {
perror("fopen");
- exit(1);
+ exit(EXIT_FAILURE);
}
fprintf(fp, "%s", buf + 1);
} else {
perror("fprintf");
- exit(1);
+ exit(EXIT_FAILURE);
}
}
}
fp = fopen(argv[1], "a");
if (fp == NULL) {
perror("fopen");
- exit(1);
+ exit(EXIT_FAILURE);
}
break;
case 'T':
}
fclose(fp);
fp = NULL;
- exit(0);
+ return EXIT_SUCCESS;
}
static volatile int do_reconfigure = 0;
static volatile int do_rotate = 0;
static volatile int do_shutdown = 0;
-static volatile int shutdown_status = 0;
+static volatile int shutdown_status = EXIT_SUCCESS;
static volatile int do_handle_stopped_child = 0;
static int RotateSignal = -1;
" -X Force full debugging.\n"
" -Y Only return UDP_HIT or UDP_MISS_NOFETCH during fast reload.\n",
APP_SHORTNAME, CACHE_HTTP_PORT, DefaultConfigFile, CACHE_ICP_PORT);
- exit(1);
+ exit(EXIT_FAILURE);
}
/**
#endif
- exit(0);
+ exit(EXIT_SUCCESS);
/* NOTREACHED */
ShutdownSignal = sig;
#if defined(SIGTTIN)
if (SIGTTIN == sig)
- shutdown_status = 1;
+ shutdown_status = EXIT_FAILURE;
#endif
#if !_SQUID_WINDOWS_
} catch (...) {
debugs(1, DBG_CRITICAL, "FATAL: " << CurrentException);
}
- return -1; // TODO: return EXIT_FAILURE instead
+ return EXIT_FAILURE;
}
/// computes name and ID for the current kid process
}
}
- exit(0);
+ exit(EXIT_SUCCESS);
}
if (setsid() < 0) {
if (TheKids.someSignaled(SIGINT) || TheKids.someSignaled(SIGTERM)) {
syslog(LOG_ALERT, "Exiting due to unexpected forced shutdown");
- exit(1);
+ exit(EXIT_FAILURE);
}
if (TheKids.allHopeless()) {
syslog(LOG_ALERT, "Exiting due to repeated, frequent failures");
- exit(1);
+ exit(EXIT_FAILURE);
}
- exit(0);
+ exit(EXIT_SUCCESS);
}
masterCheckAndBroadcastSignals();
close(2);
close(1);
close(0);
- exit(0);
+ exit(EXIT_SUCCESS);
}
int
if (open(logfile, O_WRONLY | O_CREAT | O_APPEND, 0660) < 0) {
perror(logfile);
- exit(1);
+ exit(EXIT_FAILURE);
}
close(2);
if (recvfrom(0, buf, RECV_BUF_SIZE, 0, (sockaddr *)&R, &len) < 0) {
perror("recv");
- exit(2);
+ exit(EXIT_FAILURE);
}
memcpy(ip, &R.sin_addr.s_addr, 4);
fflush(stdout);
}
- return 0;
+ return EXIT_SUCCESS;
}
break;
case 'v':
std::cout << "security_file_certgen version " << VERSION << std::endl;
- exit(0);
+ exit(EXIT_SUCCESS);
break;
case 'c':
create_new_db = true;
break;
case 'h':
usage();
- exit(0);
+ exit(EXIT_SUCCESS);
default:
- exit(0);
+ exit(EXIT_FAILURE);
}
}
std::cout << "Initialization SSL db..." << std::endl;
Ssl::CertificateDb::create(db_path);
std::cout << "Done" << std::endl;
- exit(0);
+ exit(EXIT_SUCCESS);
}
if (fs_block_size == 0) {
while (parse_result == Ssl::CrtdMessage::INCOMPLETE) {
if (fgets(request, HELPER_INPUT_BUFFER, stdin) == NULL)
- return 1;
+ exit(EXIT_FAILURE);
size_t gcount = strlen(request);
parse_result = request_message.parse(request, gcount);
}
}
} catch (std::runtime_error & error) {
std::cerr << argv[0] << ": " << error.what() << std::endl;
- return -1;
+ return EXIT_FAILURE;
}
- return 0;
+ return EXIT_SUCCESS;
}
{
fprintf(stderr, "usage: %s <access_log> <swap_state> ...\n",
prg_name);
- return -1;
+ return EXIT_FAILURE;
}
int
xfree(fis);
cacheDestroy(them);
cacheDestroy(us);
- return 0;
+ return EXIT_SUCCESS;
}
#include <iostream>
// Internal Special: the STUB framework requires this function
-#define stub_fatal(m) { std::cerr<<"FATAL: "<<(m)<<" for use of "<<__FUNCTION__<<"\n"; exit(1); }
+#define stub_fatal(m) { std::cerr<<"FATAL: "<<(m)<<" for use of "<<__FUNCTION__<<"\n"; exit(EXIT_FAILURE); }
/// macro to stub a void function.
#define STUB { stub_fatal(STUB_API " required"); }
int someMethod() {
if (!Instances)
- exit(1);
+ exit(EXIT_FAILURE);
return 1;
}
int doSomething() {
if (!Instances)
- exit (1);
+ exit(EXIT_FAILURE);
return 1;
}
};
ToRefCount anotherObject(new _ToRefCount);
if (anObject == anotherObject)
- exit (1);
+ exit(1);
anotherObject = NULL;
if (!(anObject == anotherObject))
- exit (1);
+ exit(1);
}
/* Can we get the pointer for a const object */
{
_ToRefCount const *aPointer = aConstObject.getRaw();
if (aPointer != anObject.getRaw())
- exit (2);
+ exit(2);
}
/* Can we get a refcounted pointer from a const object */
{
aBaseObject = anObject.getRaw();
}
}
- return _ToRefCount::Instances == 0 ? 0 : 1;
+ return _ToRefCount::Instances == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
HttpHdrRange *range = HttpHdrRange::ParseCreate (&aString);
if (!range)
- exit (1);
+ exit(EXIT_FAILURE);
HttpHdrRange copy(*range);
HttpHdrRange *range = HttpHdrRange::ParseCreate (&aString);
if (!range)
- exit (1);
+ exit(EXIT_FAILURE);
return range;
}
/* This passes in the extant code - but should it? */
if (!range->canonize(3))
- exit(1);
+ exit(EXIT_FAILURE);
assert (range->specs.size() == 3);
/* 0-3 needs a content length of 4 */
if (!range->canonize(4))
- exit(1);
+ exit(EXIT_FAILURE);
delete range;
/* 3-6 needs a content length of 4 or more */
if (range->canonize(3))
- exit(1);
+ exit(EXIT_FAILURE);
delete range;
/* 3-6 needs a content length of 4 or more */
if (!range->canonize(4))
- exit(1);
+ exit(EXIT_FAILURE);
delete range;
assert (range->specs.size()== 2);
if (!range->canonize(4))
- exit(1);
+ exit(EXIT_FAILURE);
assert (range->specs.size() == 2);
testRangeCanonization();
} catch (const std::exception &e) {
printf("Error: dying from an unhandled exception: %s\n", e.what());
- return 1;
+ return EXIT_FAILURE;
} catch (...) {
printf("Error: dying from an unhandled exception.\n");
- return 1;
+ return EXIT_FAILURE;
}
- return 0;
+ return EXIT_SUCCESS;
}
death(int sig)
{
std::cout << "Fatal: Signal " << sig;
- exit(1);
+ exit(EXIT_FAILURE);
}
void
fatal(const char *message)
{
fprintf(stderr, "FATAL: %s\n", message);
- exit(1);
+ exit(EXIT_FAILURE);
}
/* end stub functions */
for_each(*metadata, dumper);
- return 0;
} catch (const std::exception &e) {
std::cout << "Failed : " << e.what() << std::endl;
if (metadata)
StoreMeta::FreeList(&metadata);
- return 1;
+ return EXIT_FAILURE;
}
+
+ return EXIT_SUCCESS;
}
std::cout << "OK" << std::endl;
}
- return 0;
+ return EXIT_SUCCESS;
}
assert (BaseVirtual::Calls.deletes() == 0);
assert (ChildVirtual::Calls.news() == 1);
assert (ChildVirtual::Calls.deletes() == 1);
- return 0;
+ return EXIT_SUCCESS;
}
StreamTest *streamPointer (&aStreamObject);
debugs(1, DBG_IMPORTANT,aStreamObject);
debugs(1, DBG_IMPORTANT,streamPointer->getAnInt() << " " << aStreamObject.getACString());
- return 0;
+ return EXIT_SUCCESS;
}
assert (mem_node::InUseCount() == 0);
testHdrVisit();
assert (mem_node::InUseCount() == 0);
- return 0;
+ return EXIT_SUCCESS;
}
xassert(const char *msg, const char *file, int line)
{
std::cout << "Assertion failed: (" << msg << ") at " << file << ":" << line << std::endl;
- exit (1);
+ exit(EXIT_FAILURE);
}
#endif
assert (!(mem_node (2) < mem_node (0)));
delete aNode;
assert (mem_node::InUseCount() == 0);
- return 0;
+ return EXIT_SUCCESS;
}
/* failure */
if (!ExpectedFail)
- exit (1);
+ exit(EXIT_FAILURE);
} else
/* success */
if (ExpectedFail)
- exit (1);
+ exit(EXIT_FAILURE);
LastValue = A.i;
}
Splay<intnode> *safeTop = new Splay<intnode>();
if (safeTop->start() != NULL)
- exit (1);
+ exit(EXIT_FAILURE);
if (safeTop->finish() != NULL)
- exit (1);
+ exit(EXIT_FAILURE);
for (int i = 0; i < 100; ++i) {
intnode I;
}
if (!safeTop->start())
- exit (1);
+ exit(EXIT_FAILURE);
if (safeTop->start()->data.i != 50)
- exit (1);
+ exit(EXIT_FAILURE);
if (!safeTop->finish())
- exit (1);
+ exit(EXIT_FAILURE);
if (safeTop->finish()->data.i != 10000000)
- exit (1);
+ exit(EXIT_FAILURE);
safeTop->destroy(destintref);
}
Splay<intnode *> aSplay;
if (aSplay.start() != NULL)
- exit (1);
+ exit(EXIT_FAILURE);
if (aSplay.size() != 0)
- exit (1);
+ exit(EXIT_FAILURE);
aSplay.insert (new intnode(5), compareint);
if (aSplay.start() == NULL)
- exit (1);
+ exit(EXIT_FAILURE);
if (aSplay.size() != 1)
- exit (1);
+ exit(EXIT_FAILURE);
aSplay.destroy(destint);
if (aSplay.start() != NULL)
- exit (1);
+ exit(EXIT_FAILURE);
if (aSplay.size() != 0)
- exit (1);
+ exit(EXIT_FAILURE);
}
/* TODO: also test the other Splay API */
- return 0;
+ return EXIT_SUCCESS;
}
{
CheckHasExplicitWorks();
CheckSyntheticWorks();
- return 0;
+ return EXIT_SUCCESS;
}
char buffer[256];
regerror( result, &rexp, buffer, 256 );
fprintf( stderr, "unable to compile re \"%s\": %s\n", what, buffer );
- exit(1);
+ exit(EXIT_FAILURE);
}
}
regerror( result, &rexp, buffer, 256 );
fprintf( stderr, "unable to execute re \"%s\"\n+ on line \"%s\": %s\n",
data, check, buffer );
- exit(1);
+ exit(EXIT_FAILURE);
}
return ( result == 0 );
}
char* result = new char[size];
if ( result == 0 ) {
perror( "string memory allocation" );
- exit(1);
+ exit(EXIT_FAILURE);
}
// second run: copy content
case 'c':
if ( !optarg || !*optarg ) {
fprintf( stderr, "%c requires a regex pattern argument!\n", option );
- exit(1);
+ exit(EXIT_FAILURE);
}
if ( *conffile ) xfree((void*) conffile);
conffile = xstrdup(optarg);
case 'e':
if ( !optarg || !*optarg ) {
fprintf( stderr, "%c requires a regex pattern argument!\n", option );
- exit(1);
+ exit(EXIT_FAILURE);
}
if ( head == 0 )
tail = head = new REList( optarg, option=='E' );
case 'f':
if ( !optarg || !*optarg ) {
fprintf( stderr, "%c requires a filename argument!\n", option );
- exit(1);
+ exit(EXIT_FAILURE);
}
if ( (rfile = fopen( optarg, "r" )) != NULL ) {
unsigned long lineno = 0;
if ( len+2 >= LINESIZE ) {
fprintf( stderr, "%s:%lu: line too long, sorry.\n",
optarg, lineno );
- exit(1);
+ exit(EXIT_FAILURE);
}
// remove trailing line breaks
case 'p':
if ( !optarg || !*optarg ) {
fprintf( stderr, "%c requires a port argument!\n", option );
- exit(1);
+ exit(EXIT_FAILURE);
}
colon = strchr( optarg, ':' );
if ( colon == 0 ) {
// assume that main() did set the default port
if ( convertHostname(optarg,serverHostIp) == -1 ) {
fprintf( stderr, "unable to resolve host %s!\n", optarg );
- exit(1);
+ exit(EXIT_FAILURE);
}
} else {
// assume that main() did set the default host
++colon;
if ( convertHostname(optarg,serverHostIp) == -1 ) {
fprintf( stderr, "unable to resolve host %s!\n", optarg );
- exit(1);
+ exit(EXIT_FAILURE);
}
if ( convertPortname(colon,serverHostPort) == -1 ) {
fprintf( stderr, "unable to resolve port %s!\n", colon );
- exit(1);
+ exit(EXIT_FAILURE);
}
}
break;
case 'P':
if ( !optarg || !*optarg ) {
fprintf( stderr, "%c requires a mode argument!\n", option );
- exit(1);
+ exit(EXIT_FAILURE);
}
::purgeMode = ( strtol( optarg, 0, 0 ) & 0x07 );
break;
case '?':
default:
helpMe();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
if ( head == 0 ) {
fputs( "There was no regular expression defined. If you intend\n", stderr );
fputs( "to match all possible URLs, use \"-e .\" instead.\n", stderr );
- exit(1);
+ exit(EXIT_FAILURE);
}
// postcondition: head != 0
handler( int signo ) {
::term_flag = signo;
if ( getpid() == getpgrp() ) kill( -getpgrp(), signo );
- exit(1);
+ exit(EXIT_FAILURE);
}
} // extern "C"
serverPort = htons(DEFAULTPORT);
if ( convertHostname(DEFAULTHOST,serverHost) == -1 ) {
fprintf( stderr, "unable to resolve host %s!\n", DEFAULTHOST );
- return 1;
+ exit(EXIT_FAILURE);
}
// setup line buffer
Signal( SIGINT, handler, true ) == SIG_ERR ||
Signal( SIGHUP, handler, true ) == SIG_ERR ) {
perror( "unable to install signal/exit function" );
- return 1;
+ exit(EXIT_FAILURE);
}
// try to read squid.conf file to determine all cache_dir locations
// make parent process group leader for easier killings
if ( setpgid(getpid(), getpid()) != 0 ) {
perror( "unable to set process group leader" );
- return 1;
+ exit(EXIT_FAILURE);
}
// -a is mutually exclusive with fork mode
// fork error, this is bad!
perror( "unable to fork" );
kill( -getpgrp(), SIGTERM );
- return 1;
+ exit(EXIT_FAILURE);
} else if ( child[i] == 0 ) {
// child mode
// execute OR complain
fprintf( stderr, "program terminated due to error: %s\n",
strerror(errno) );
xfree((void*) cdv[i].base);
- return 0;
+ exit(EXIT_SUCCESS);
} else {
// parent mode
if ( ::debugFlag ) printf( "forked child %d\n", (int) child[i] );
if ( copydir ) xfree( (void*) copydir );
xfree((void*) conffile);
delete list;
- return 0;
+ return EXIT_SUCCESS;
}
<< " -w password Proxy authentication password" << std::endl
<< " -W password WWW authentication password" << std::endl
;
- exit(1);
+ exit(EXIT_FAILURE);
}
static void
if (put_fd < 0) {
int xerrno = errno;
std::cerr << "ERROR: can't open file (" << xstrerr(xerrno) << ")" << std::endl;
- exit(-1);
+ exit(EXIT_FAILURE);
}
#if _SQUID_WINDOWS_
setmode(put_fd, O_BINARY);
#endif
if (!password) {
std::cerr << "ERROR: Proxy password missing" << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
uint8_t *pwdBuf = new uint8_t[base64_encode_len(strlen(user)+1+strlen(password))];
blen = base64_encode_update(&ctx, pwdBuf, strlen(user), reinterpret_cast<const uint8_t*>(user));
#endif
if (!password) {
std::cerr << "ERROR: WWW password missing" << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
uint8_t *pwdBuf = new uint8_t[base64_encode_len(strlen(user)+1+strlen(password))];
blen = base64_encode_update(&ctx, pwdBuf, strlen(user), reinterpret_cast<const uint8_t*>(user));
if (bytesWritten < 0) {
std::cerr << "ERROR: write" << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
} else if ((unsigned) bytesWritten != strlen(msg)) {
std::cerr << "ERROR: Cannot send request?: " << std::endl << msg << std::endl;
- exit(1);
+ exit(EXIT_FAILURE);
}
debugVerbose(2, "done.");
Ping::DisplayStats();
Transport::ShutdownTls();
- return 0;
+ return EXIT_SUCCESS;
}
void
if (sigaction(SIGPIPE, &sa, NULL) < 0) {
std::cerr << "ERROR: Cannot set PIPE signal." << std::endl;
- exit(-1);
+ exit(EXIT_FAILURE);
}
#else
signal(SIGPIPE, pipe_handler);
projects / thirdparty / squid.git / commitdiff
