void PNGAPI png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location) { /* This API is pretty pointless in 1.6.0 because the location can be set * before the call to png_set_unknown_chunks. * * TODO: add a png_app_warning in 1.7 */ if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < info_ptr->unknown_chunks_num) { if ((location & (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)) == 0) { png_app_error(png_ptr, "invalid unknown chunk location"); /* Fake out the pre 1.6.0 behavior: */ if ((location & PNG_HAVE_IDAT) != 0) /* undocumented! */ location = PNG_AFTER_IDAT; else location = PNG_HAVE_IHDR; /* also undocumented */ } info_ptr->unknown_chunks[chunk].location = check_location(png_ptr, location); } }
void update_all(node **head, int step, date_time time_stamp) { node *current = *head; for (current = *head; current != NULL; current = current->next) { current->loc = update_location(current->loc, current->speed, current->course, step); int new_area = check_location(current->loc, current->course); FILE *log = fopen(log_file, "a"); if (current->in_area == 0 && new_area != 0) { printf("\nShip %s has left shipping area", current->ais_id); fprintf(log, "\nShip left: %s\nTime: %d %d %d %d:%d:%d", current->ais_id, time_stamp.day, time_stamp.month, time_stamp.year, time_stamp.hours, time_stamp.minutes, time_stamp.seconds); } else if (current->in_area != 0 && new_area == 0) { printf("\nShip %s has entered shipping area", current->ais_id); fprintf(log, "Ship Entered: %s\nTime: %d %d %d %d:%d:%d", current->ais_id, time_stamp.day, time_stamp.month, time_stamp.year, time_stamp.hours, time_stamp.minutes, time_stamp.seconds); } fclose(log); current->in_area = new_area; } }
/* * Format: * ${LETTER}${NUMBER}[[-/]${LETTER}${NUMBER} [ ... ] ] * the '.' may be an abbrevation */ static void check_location_string(struct seq_file *m, const char *c) { while (*c) { if (isalpha(*c) || *c == '.') check_location(m, c); else if (*c == '/' || *c == '-') seq_printf(m, " at "); c++; } }
/* * Rewind the buffer, and check that the virtual pointer is at 0. * buffer: the buffer to rewind * returns 1 if the rewind was successful, 0 otherwise */ static int check_rewind(file_buffer_t *buffer) { rewind_buffer(buffer); if (!check_location(buffer, 0)) { printlg(ERROR_LEVEL, "Failed to rewind.\n"); return 0; } return 1; }
/***************************************************************** checks to see if passed token has a valid move Parameters: char: either 'B' or 'W', token of player to check for; int: size of the board; char**: 2d array of the board; Returns: 0: if no moves; 1: if has valid moves; *****************************************************************/ int check_valid_moves(char token, int size, char board[][size]) { //move through each row for (int i = 0; i < size; i++) { //move through each column for (int j = 0; j < size; j++) { //check if location has been played if (board[i][j] == '-') { /*check if there is a valid move from this location if there is one valid more for this token stop looking and return true*/ if (check_location(token, i, j, size, board) > 0) { return 1; } } } } return 0; }
/** * main function prompts user for input, reads file and runs simulate function. */ int main(int argc, char** argv) { date_time time_stamp; char path[100], ais_id[21]; double duration, lat, lng, course, speed; int mins_duration, step; FILE *file; node *list_head = NULL; /*get information from user*/ printf("Please enter the path of the file of ship data: "); scanf(" %s", path); printf("Please enter the size of each time step in mins: "); scanf("%d", &step); printf("Please enter the duration of the simulation in hours(1.5 = 1h 30m): "); scanf("%lf", &duration); mins_duration = duration * 60; //multiply by 60 to get duration in minutes. /*attempt to read file, and simulate if read succeeds*/ file = fopen(path, "r"); if (file != NULL) { fscanf(file, "%d %d %d %d %d %d", &time_stamp.day, &time_stamp.month, &time_stamp.year, &time_stamp.hours, &time_stamp.minutes, &time_stamp.seconds); sprintf(log_file, "./LOG_%d_%d_%d_%d_%d_%d", time_stamp.day, time_stamp.month, time_stamp.year, time_stamp.hours, time_stamp.minutes, time_stamp.seconds); while ((fscanf(file, " %s %lf %lf %lf %lf", ais_id, &lat, &lng, &course, &speed)) != EOF) { node *new_node = make_node(ais_id, lat, lng, course, speed); new_node->in_area = check_location(new_node->loc, new_node->course); add_node(&list_head, new_node); } fclose(file); simulate(&list_head, step, mins_duration, &time_stamp); print_all(&list_head); } else { printf("\nfile not found"); } return (EXIT_SUCCESS); }
void PNGAPI png_set_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns) { png_unknown_chunkp np; if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 || unknowns == NULL) return; /* Check for the failure cases where support has been disabled at compile * time. This code is hardly ever compiled - it's here because * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this * code) but may be meaningless if the read or write handling of unknown * chunks is not compiled in. */ # if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \ defined(PNG_READ_SUPPORTED) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) { png_app_error(png_ptr, "no unknown chunk support on read"); return; } # endif # if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \ defined(PNG_WRITE_SUPPORTED) if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0) { png_app_error(png_ptr, "no unknown chunk support on write"); return; } # endif /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that * unknown critical chunks could be lost with just a warning resulting in * undefined behavior. Now png_chunk_report is used to provide behavior * appropriate to read or write. */ np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr, info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns, sizeof *np)); if (np == NULL) { png_chunk_report(png_ptr, "too many unknown chunks", PNG_CHUNK_WRITE_ERROR); return; } png_free(png_ptr, info_ptr->unknown_chunks); info_ptr->unknown_chunks = np; /* safe because it is initialized */ info_ptr->free_me |= PNG_FREE_UNKN; np += info_ptr->unknown_chunks_num; /* Increment unknown_chunks_num each time round the loop to protect the * just-allocated chunk data. */ for (; num_unknowns > 0; --num_unknowns, ++unknowns) { memcpy(np->name, unknowns->name, (sizeof np->name)); np->name[(sizeof np->name)-1] = '\0'; np->location = check_location(png_ptr, unknowns->location); if (unknowns->size == 0) { np->data = NULL; np->size = 0; } else { np->data = png_voidcast(png_bytep, png_malloc_base(png_ptr, unknowns->size)); if (np->data == NULL) { png_chunk_report(png_ptr, "unknown chunk: out of memory", PNG_CHUNK_WRITE_ERROR); /* But just skip storing the unknown chunk */ continue; } memcpy(np->data, unknowns->data, unknowns->size); np->size = unknowns->size; } /* These increments are skipped on out-of-memory for the data - the * unknown chunk entry gets overwritten if the png_chunk_report returns. * This is correct in the read case (the chunk is just dropped.) */ ++np; ++(info_ptr->unknown_chunks_num); } }
/* * helper function for automatically finding an invalid seeking mode * returns a seeking mode that is not one of the 3 legal ones */ static int find_bad_mode() { #ifdef DEBUG size_t n_tries = 0; #endif /* DEBUG */ int try = INT_MIN; while (try <= INT_MAX) { if (try != SEEK_SET && try != SEEK_CUR && try != SEEK_END) { return try; } try++; #ifdef DEBUG n_tries++; debug_assert(n_tries < N_SEEK_MODES); #endif /* DEBUG */ } return try; } /* * Test that an error in "fseek_buffer" is properly caught, * and does not change the state of the buffer. * buffer: the buffer in which to make an invalid seek * offset: the "offset" argument to "fseek_buffer" * whence: the "whence" argument to "fseek_buffer" * expected_errno: the expected value of "errno" * returns 1 if the error was properly handled, 0 otherwise */ static int test_fseek_error(file_buffer_t *buffer, long offset, int whence, int expected_errno) { long old_location = ftell_buffer(buffer); if (fseek_buffer(buffer, offset, whence) == 0) { printlg(ERROR_LEVEL, "Did not catch fseek error.\n"); return 0; } if (expected_errno != errno) { printlg(ERROR_LEVEL, "Expected error %d for bad destination, " "but got %d.\n", expected_errno, errno); return 0; } if (!check_location(buffer, old_location)) { printlg(ERROR_LEVEL, "Location moved, in spite of failed seek.\n"); return 0; } return 1; } #pragma GCC diagnostic ignored "-Wunused-parameter" static int error_read_tester(file_buffer_t *buffer, unsigned char *file_map) { int bad_mode = find_bad_mode(); if (!test_fseek_error(buffer, 0, bad_mode, EINVAL)) { printlg(ERROR_LEVEL, "Did not catch bad mode, %d.\n", bad_mode); return 0; } if (!test_fseek_error(buffer, SMALL_SIZE + 1, SEEK_SET, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "directly jumping past end of file.\n"); return 0; } if (!test_fseek_error(buffer, -1, SEEK_SET, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "directly jumping to a negative value.\n"); return 0; } if (fseek_buffer(buffer, SMALL_SIZE / 2, SEEK_SET)) { printlg(ERROR_LEVEL, "Failed to jump to the middle of the file.\n"); return 0; } if (!test_fseek_error(buffer, SMALL_SIZE, SEEK_CUR, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "making relative jump past end of file.\n"); return 0; } if (!test_fseek_error(buffer, -SMALL_SIZE, SEEK_CUR, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "making relative jump to a negative destination.\n"); return 0; } if (!test_fseek_error(buffer, 1, SEEK_END, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "jumping past end of file.\n"); return 0; } if (!test_fseek_error(buffer, -(SMALL_SIZE + 1), SEEK_END, ERANGE)) { printlg(ERROR_LEVEL, "Did not detect error when " "jumping past beginning of file.\n"); return 0; } return 1; } #pragma GCC diagnostic error "-Wunused-parameter" /* Check that invalid calls to "fseek_buffer" are properly reported. */ static struct file_buffer_tv error_read = { .file_name = SMALL_FILE, .tester = error_read_tester }; struct file_buffer_tv *file_buffer_tvs[N_FILE_BUFFER_TVS] = { &full_read, &segmented_read, &small_read, &smaller_read, &jumping_read, &error_read };
static int jumping_read_tester(file_buffer_t *buffer, unsigned char *file_map) { /* Jump to the end, and don't expect to read any bytes. */ if (fseek_buffer(buffer, 0, SEEK_END)) { printlg(ERROR_LEVEL, "Failed to jump to end of file.\n"); return 0; } if (!check_location(buffer, LARGE_SIZE)) { printlg(ERROR_LEVEL, "Failed to reach end of file.\n"); return 0; } if (fgetc_buffer(buffer) != EOF) { printlg(ERROR_LEVEL, "Did not expect to " "read a byte at the end of the file.\n"); return 0; } /* Read a page, and then read some of the earlier bytes. */ if (!check_rewind(buffer)) { printlg(ERROR_LEVEL, "Failed to rewind from end.\n"); return 0; } debug_assert(LARGE_SIZE > PAGE_SIZE); if (!read_check(buffer, file_map, PAGE_SIZE, PAGE_SIZE)) { printlg(ERROR_LEVEL, "Failed to read first page.\n"); return 0; } #define PAGE_BACK_JUMP (-PAGE_SIZE * 3 / 4) if (fseek_buffer(buffer, -PAGE_BACK_JUMP, SEEK_CUR)) { printlg(ERROR_LEVEL, "Failed to jump into first page.\n"); return 0; } if (!check_location(buffer, PAGE_SIZE - PAGE_BACK_JUMP)) { printlg(ERROR_LEVEL, "Failed to jump into first page.\n"); return 0; } if (!read_check(buffer, file_map, SMALL_SEGMENT, SMALL_SEGMENT)) { printlg(ERROR_LEVEL, "Failed to read inside first page.\n"); return 0; } /* Rewind, and read part of the first page. */ if (!check_rewind(buffer)) { printlg(ERROR_LEVEL, "Failed to rewind from inside page.\n"); return 0; } if (!read_check(buffer, file_map, SMALL_SEGMENT, SMALL_SEGMENT)) { printlg(ERROR_LEVEL, "Failed to read beginning.\n"); return 0; } /* Read after the first page, and read beginning again. */ debug_assert(LARGE_SIZE > LARGE_SEGMENT + SMALL_SEGMENT); if (fseek_buffer(buffer, LARGE_SEGMENT, SEEK_SET)) { printlg(ERROR_LEVEL, "Failed to jump past first page.\n"); return 0; } if (!check_location(buffer, LARGE_SEGMENT)) { printlg(ERROR_LEVEL, "Failed to reach location past first page.\n"); return 0; } if (!read_check(buffer, file_map, SMALL_SEGMENT, SMALL_SEGMENT)) { printlg(ERROR_LEVEL, "Failed to read after first page.\n"); return 0; } if (!check_rewind(buffer)) { printlg(ERROR_LEVEL, "Failed to rewind to first page.\n"); return 0; } if (!read_check(buffer, file_map, SMALL_SEGMENT, SMALL_SEGMENT)) { printlg(ERROR_LEVEL, "Failed to read first page " "after jumping back to it.\n"); return 0; } return 1; }
PAM_EXTERN int pam_sm_acct_mgmt(pam_handle_t *pamh, int flags, int argc, const char **argv) { struct options *opts; FILE *fh; char *username; /* username requesting access */ char *rhost; /* remote host */ char *srv; /* PAM service we're running as */ char buf[LINE_LENGTH]; int retval, action; int is_v6 = 0; struct locations *geo; unsigned char gi_type; GeoIP *gi = NULL; #ifdef HAVE_GEOIP_010408 GeoIP *gi6 = NULL; int is_city6_db = 0; #endif GeoIPRecord *rec = NULL; opts = malloc(sizeof(struct options)); if (opts == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'opts': %m"); return PAM_SERVICE_ERR; } opts->charset = GEOIP_CHARSET_UTF8; opts->debug = 0; opts->action = PAM_PERM_DENIED; opts->system_file = NULL; opts->service_file = NULL; opts->by_service = 0; opts->geoip_db = NULL; #ifdef HAVE_GEOIP_010408 opts->use_v6 = 0; opts->v6_first = 0; opts->geoip6_db = NULL; #endif opts->is_city_db = 0; geo = malloc(sizeof(struct locations)); if (geo == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'geo': %m"); free_opts(opts); return PAM_SERVICE_ERR; } geo->country = NULL; geo->city = NULL; geo->next = NULL; _parse_args(pamh, argc, argv, opts); if (opts->system_file == NULL) opts->system_file = strdup(SYSTEM_FILE); if (opts->system_file == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->system_file': %m"); free_opts(opts); return PAM_SERVICE_ERR; } if (opts->geoip_db == NULL) opts->geoip_db = strdup(GEOIPDB_FILE); if (opts->geoip_db == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip_db': %m"); free_opts(opts); return PAM_SERVICE_ERR; } #ifdef HAVE_GEOIP_010408 if (opts->geoip6_db == NULL) opts->geoip6_db = strdup(GEOIP6DB_FILE); if (opts->geoip6_db == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip6_db': %m"); free_opts(opts); return PAM_SERVICE_ERR; } #endif retval = pam_get_item(pamh, PAM_USER, (void*) &username); if (username == NULL || retval != PAM_SUCCESS) { pam_syslog(pamh, LOG_CRIT, "error recovering username"); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } retval = pam_get_item(pamh, PAM_RHOST, (void*) &rhost); if (retval != PAM_SUCCESS) { pam_syslog(pamh, LOG_CRIT, "error fetching rhost"); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } if (rhost == NULL) { pam_syslog(pamh, LOG_INFO, "rhost is NULL, allowing"); free_opts(opts); free_locations(geo); return PAM_SUCCESS; } retval = pam_get_item(pamh, PAM_SERVICE, (void*) &srv); if (srv == NULL || retval != PAM_SUCCESS ) { pam_syslog(pamh, LOG_CRIT, "error requesting service name"); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } opts->service_file = malloc(PATH_MAX); if (opts->service_file == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'service_file': %m"); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } if (snprintf(opts->service_file, PATH_MAX-1, SERVICE_FILE, srv) < 0) { pam_syslog(pamh, LOG_CRIT, "snprintf error 'service_file'"); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } gi = GeoIP_open(opts->geoip_db, GEOIP_INDEX_CACHE); if (gi == NULL) { pam_syslog(pamh, LOG_CRIT, "failed to open geoip db (%s): %m", opts->geoip_db); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } gi_type = GeoIP_database_edition(gi); if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP edition: %d", gi_type); switch (gi_type) { case GEOIP_COUNTRY_EDITION: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: country"); opts->is_city_db = 0; break; case GEOIP_CITY_EDITION_REV0: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev0"); opts->is_city_db = 1; break; case GEOIP_CITY_EDITION_REV1: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev1"); opts->is_city_db = 1; break; default: pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type); GeoIP_delete(gi); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } GeoIP_set_charset(gi, opts->charset); if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City: %s", opts->is_city_db ? "yes" : "no"); #ifdef HAVE_GEOIP_010408 if (opts->use_v6 != 0) { gi6 = GeoIP_open(opts->geoip6_db, GEOIP_INDEX_CACHE); if (gi6 == NULL) { pam_syslog(pamh, LOG_CRIT, "failed to open geoip6 db (%s): %m", opts->geoip6_db); GeoIP_delete(gi); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } gi_type = GeoIP_database_edition(gi6); switch (gi_type) { case GEOIP_COUNTRY_EDITION_V6: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: country"); is_city6_db = 0; break; case GEOIP_CITY_EDITION_REV0_V6: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev0"); is_city6_db = 1; break; case GEOIP_CITY_EDITION_REV1_V6: if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev1"); is_city6_db = 1; break; default: pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type); GeoIP_delete(gi); GeoIP_delete(gi6); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City v6: %s", is_city6_db ? "yes" : "no"); GeoIP_set_charset(gi6, opts->charset); if (opts->is_city_db != is_city6_db) { pam_syslog(pamh, LOG_CRIT, "IPv4 DB type is not the same as IPv6 (not both Country edition or both City edition)"); GeoIP_delete(gi); GeoIP_delete(gi6); free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } if (opts->v6_first != 0) { rec = GeoIP_record_by_name_v6(gi6, rhost); if (rec == NULL) { if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "no IPv6 record for %s, trying IPv4", rhost); rec = GeoIP_record_by_name(gi, rhost); } else is_v6 = 1; } else { rec = GeoIP_record_by_name(gi, rhost); if (rec == NULL) { if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "no IPv4 record for %s, trying IPv6", rhost); rec = GeoIP_record_by_name_v6(gi6, rhost); if (rec != NULL) is_v6 = 1; } } } else #endif /* HAVE_GEOIP_010408 */ rec = GeoIP_record_by_name(gi, rhost); if (rec == NULL) { pam_syslog(pamh, LOG_INFO, "no record for %s, setting GeoIP to 'UNKNOWN,*'", rhost); geo->city = strdup("*"); geo->country = strdup("UNKNOWN"); if (geo->city == NULL || geo->country == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m"); GeoIP_delete(gi); #ifdef HAVE_GEOIP_010408 GeoIP_delete(gi6); #endif free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } } else { if (rec->city == NULL || opts->is_city_db == 0) geo->city = strdup("*"); else geo->city = strdup(rec->city); if (rec->country_code == NULL) geo->country = strdup("UNKNOWN"); else geo->country = strdup(rec->country_code); if (geo->city == NULL || geo->country == NULL) { pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m"); GeoIP_delete(gi); #ifdef HAVE_GEOIP_010408 GeoIP_delete(gi6); #endif free_opts(opts); free_locations(geo); return PAM_SERVICE_ERR; } if (opts->is_city_db) { geo->latitude = rec->latitude; geo->longitude = rec->longitude; } } if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "GeoIP record for %s: %s,%s", rhost, geo->country, geo->city); if (opts->debug && strcmp(geo->country, "UNKNOWN") != 0 && opts->is_city_db) pam_syslog(pamh, LOG_DEBUG, "GeoIP coordinates for %s: %f,%f", rhost, geo->latitude, geo->longitude); if ((fh = fopen(opts->service_file, "r")) != NULL) { opts->by_service = 1; if (opts->debug) pam_syslog(pamh, LOG_DEBUG, "using services file %s", opts->service_file); } else { if ((fh = fopen(opts->system_file, "r")) == NULL) { pam_syslog(pamh, LOG_CRIT, "error opening %s: %m", opts->system_file); #ifdef HAVE_GEOIP_010408 if (gi6) GeoIP_delete(gi6); #endif if (gi) GeoIP_delete(gi); if (rec) GeoIPRecord_delete(rec); free_opts(opts); return PAM_SERVICE_ERR; } } action = opts->action; char location[LINE_LENGTH]; while (fgets(buf, LINE_LENGTH, fh) != NULL) { char *line, *ptr; char domain[LINE_LENGTH], service[LINE_LENGTH]; action = opts->action; line = buf; /* skip the leading white space */ while (*line && isspace(*line)) line++; /* Rip off the comments */ ptr = strchr(line,'#'); if (ptr) *ptr = '\0'; /* Rip off the newline char */ ptr = strchr(line,'\n'); if (ptr) *ptr = '\0'; /* Anything left ? */ if (!strlen(line)) continue; if (opts->by_service) action = parse_line_srv(pamh, line, domain, location); else action = parse_line_sys(pamh, line, domain, service, location); if (action < 0) { /* parsing failed */ action = opts->action; continue; } if (!opts->by_service) { if (!check_service(pamh, service, srv)) continue; } if ((strcmp(domain, "*") == 0) || (strcmp(username, domain) == 0)) { if (check_location(pamh, opts, location, geo)) break; } else if (domain[0] == '@') { if (pam_modutil_user_in_group_nam_nam(pamh, username, domain+1)) { if (check_location(pamh, opts, location, geo)) break; } } } fclose(fh); if (gi) GeoIP_delete(gi); #ifdef HAVE_GEOIP_010408 if (gi6) GeoIP_delete(gi6); #endif if (rec) GeoIPRecord_delete(rec); free_locations(geo); switch (action) { case PAM_SUCCESS: pam_syslog(pamh, LOG_DEBUG, "location %s allowed for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4); break; case PAM_PERM_DENIED: pam_syslog(pamh, LOG_DEBUG, "location %s denied for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4); break; case PAM_IGNORE: pam_syslog(pamh, LOG_DEBUG, "location %s ignored for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4); break; default: /* should not happen */ pam_syslog(pamh, LOG_DEBUG, "location status: %d, IPv%d", action, is_v6 ? 6 : 4); break; }; free_opts(opts); return action; }