/** * prelude_string_cat: * @dst: Pointer to a #prelude_string_t object. * @str: Pointer to a string. * @len: Length of @str to copy. * * The prelude_string_ncat() function appends @len characters from @str to * the @dst #prelude_string_t object over-writing the `\0' character at the * end of @dst, and then adds a termi-nating `\0' character. * * Returns: @len, or a negative value if an error occured. */ int prelude_string_ncat(prelude_string_t *dst, const char *str, size_t len) { int ret; prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(str, prelude_error(PRELUDE_ERROR_ASSERTION)); if ( dst->flags & PRELUDE_STRING_OWN_DATA && len < (dst->size - dst->index) ) { memcpy(dst->data.rwbuf + dst->index, str, len); dst->index += len; dst->data.rwbuf[dst->index] = '\0'; return len; } if ( len + 1 < len ) return prelude_error(PRELUDE_ERROR_INVAL_LENGTH); ret = allocate_more_chunk_if_needed(dst, len + 1); if ( ret < 0 ) return ret; return prelude_string_ncat(dst, str, len); }
/** * prelude_string_get_string_released: * @string: Pointer to a #prelude_string_t object. * @outptr: Pointer to an address where to store the released string. * * Get @string content, and release it so that further operation on * @string won't modify the returned content. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_get_string_released(prelude_string_t *string, char **outptr) { prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); *outptr = NULL; if ( ! string->index ) return 0; if ( ! (string->flags & PRELUDE_STRING_OWN_DATA) ) { *outptr = strdup(string->data.robuf); return (*outptr) ? 0 : prelude_error_from_errno(errno); } if ( string->index + 1 <= string->index ) return prelude_error(PRELUDE_ERROR_INVAL_LENGTH); *outptr = _prelude_realloc(string->data.rwbuf, string->index + 1); if ( ! *outptr ) return prelude_error_from_errno(errno); string->size = 0; string->index = 0; string->data.rwbuf = NULL; return 0; }
/** * prelude_string_cat: * @dst: Pointer to a #prelude_string_t object. * @str: Pointer to a string. * * The prelude_string_cat() function appends the @str string to the @dst * prelude_string_t object over-writing the `\0' character at the end of * @dst, and then adds a termi-nating `\0' character. * * Returns: @len, or a negative value if an error occured. */ int prelude_string_cat(prelude_string_t *dst, const char *str) { prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(str, prelude_error(PRELUDE_ERROR_ASSERTION)); return prelude_string_ncat(dst, str, strlen(str)); }
/** * prelude_string_set_ref: * @string: Pointer to a #prelude_string_t object. * @buf: String to store in @string. * * Store a reference to the string pointed by @buf in @string. * The referenced @buf value won't be modified or freed. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_set_ref(prelude_string_t *string, const char *buf) { prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); return prelude_string_set_ref_fast(string, buf, strlen(buf)); }
/** * idmef_time_set_from_ntpstamp: * @time: Pointer to a #idmef_time_t object. * @buf: Pointer to a string containing an NTP timestamp. * * Fills the @time object with information provided within the @buf NTP timestamp. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_set_from_ntpstamp(idmef_time_t *time, const char *buf) { l_fp ts; struct timeval tv; unsigned ts_mask = TS_MASK; unsigned ts_roundbit = TS_ROUNDBIT; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); if ( sscanf(buf, "%x.%x", &ts.l_ui, &ts.l_uf) < 2 ) return -1; /* * This transformation is a reverse form of the one found in * idmef_get_ntp_timestamp() */ ts.l_ui -= JAN_1970; ts.l_uf -= ts_roundbit; ts.l_uf &= ts_mask; TSTOTV(&ts, &tv); time->sec = tv.tv_sec; time->usec = tv.tv_usec; time->gmt_offset = 0; return 0; }
/** * idmef_time_copy: * @src: Pointer to a #idmef_time_t to copy data from. * @dst: Pointer to a #idmef_time_t to copy data to. * * Copies @src internal to @dst. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_copy(const idmef_time_t *src, idmef_time_t *dst) { prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION)); dst->sec = src->sec; dst->usec = src->usec; dst->gmt_offset = src->gmt_offset; return 0; }
/** * prelude_string_copy_ref: * @src: Pointer to a #prelude_string_t object to copy data from. * @dst: Pointer to a #prelude_string_t object to copy data to. * * Reference @src content within @dst. * The referenced content won't be modified or freed. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_copy_ref(const prelude_string_t *src, prelude_string_t *dst) { prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_string_destroy_internal(dst); dst->size = src->size; dst->index = src->index; dst->data.robuf = src->data.robuf; dst->flags &= ~PRELUDE_STRING_OWN_DATA; return 0; }
/** * prelude_client_profile_set_name: * @cp: Pointer to a #prelude_client_profile_t object. * @name: Name to associate the profile with. * * Sets the prelude client profile name. * * Returns: 0 on success or a negative value if an error occured. */ int prelude_client_profile_set_name(prelude_client_profile_t *cp, const char *name) { prelude_return_val_if_fail(cp, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(name, prelude_error(PRELUDE_ERROR_ASSERTION)); if ( cp->name ) free(cp->name); cp->name = strdup(name); if ( ! cp->name ) return prelude_error_from_errno(errno); return 0; }
/** * prelude_string_sprintf: * @string: Pointer to a #prelude_string_t object. * @fmt: Format string to use. * @...: Variable argument list. * * Produce output according to @fmt, and write output to the given * @string. See snprintf(3) to learn more about @fmt format. * * Returns: The number of characters written, or a negative value if an error occured. */ int prelude_string_sprintf(prelude_string_t *string, const char *fmt, ...) { int ret; va_list ap; prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(fmt, prelude_error(PRELUDE_ERROR_ASSERTION)); va_start(ap, fmt); ret = prelude_string_vprintf(string, fmt, ap); va_end(ap); return ret; }
/** * prelude_string_clone: * @src: Pointer to an existing #prelude_string_t object. * @dst: Pointer to an address where to store the created #prelude_string_t object. * * Clone @src within a new #prelude_string_t object stored into @dst. * Data carried by @dst and @src are independant. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_clone(const prelude_string_t *src, prelude_string_t **dst) { int ret; prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = prelude_string_new(dst); if ( ret < 0 ) return ret; (*dst)->size = src->size; (*dst)->index = src->index; (*dst)->flags |= PRELUDE_STRING_OWN_DATA; if ( src->size ) { (*dst)->data.rwbuf = malloc(src->size); if ( ! (*dst)->data.rwbuf ) { prelude_string_destroy(*dst); return prelude_error_from_errno(errno); } string_buf_copy(*dst, src->data.robuf, src->index); } return 0; }
/** * prelude_string_set_ref_fast: * @string: Pointer to a #prelude_string_t object. * @buf: String to store in @string. * @len: Lenght of @buf. * * Store a reference to the string pointed by @buf in @string. * The referenced @buf value won't be modified or freed. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_set_ref_fast(prelude_string_t *string, const char *buf, size_t len) { prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); STRING_RETURN_IF_INVALID(buf, len); prelude_string_destroy_internal(string); string->index = len; string->size = len + 1; string->data.robuf = buf; string->flags &= ~PRELUDE_STRING_OWN_DATA; return 0; }
static int allocate_more_chunk_if_needed(prelude_string_t *s, size_t needed_len) { int ret; char *ptr; size_t len; if ( ! needed_len ) len = BUFFER_CHUNK_SIZE; else len = MAX(needed_len - (s->size - s->index), s->size * BUFFER_GROWTH_FACTOR); if ( s->size + len < s->size ) return prelude_error(PRELUDE_ERROR_INVAL_LENGTH); if ( s->flags & PRELUDE_STRING_OWN_DATA ) { ptr = _prelude_realloc(s->data.rwbuf, s->size + len); if ( ! ptr ) return prelude_error_from_errno(errno); s->size += len; s->data.rwbuf = ptr; } else { ret = make_string_own(s, s->size + len); if ( ret < 0 ) return ret; } return 0; }
int _prelude_log_set_abort_level_from_string(const char *level) { size_t i; char *eptr; long lvalue; struct { const char *prefix; prelude_log_t level; } tbl[] = { { "CRIT", PRELUDE_LOG_CRIT }, { "ERR", PRELUDE_LOG_ERR }, { "WARN", PRELUDE_LOG_WARN }, { "INFO", PRELUDE_LOG_INFO }, { "DEBUG", PRELUDE_LOG_DEBUG } }; prelude_return_val_if_fail(level != NULL, prelude_error(PRELUDE_ERROR_ASSERTION)); for ( i = 0; i < sizeof(tbl) / sizeof(*tbl); i++ ) { if ( strncasecmp(tbl[i].prefix, level, strlen(tbl[i].prefix)) == 0 ) { _prelude_log_set_abort_level(tbl[i].level); return 0; } } lvalue = strtol(level, &eptr, 10); if ( eptr != (level + strlen(level)) || lvalue == LONG_MIN || lvalue == LONG_MAX ) { prelude_log(PRELUDE_LOG_WARN, "Invalid abort level specified: '%s'.\n", level); return -1; } _prelude_log_set_abort_level(lvalue); return 0; }
/** * prelude_read_multiline: * @fd: File descriptor to read input from. * @line: Pointer to a line counter. * @buf: Pointer to a buffer where the line should be stored. * @size: Size of the @buf buffer. * * This function handles line reading separated by the '\' character. * * Returns: 0 on success, -1 if an error occured. */ int prelude_read_multiline(FILE *fd, unsigned int *line, char *buf, size_t size) { size_t i, j, len; prelude_bool_t eol, has_data = FALSE, miss_eol=FALSE; while ( size > 1 ) { if ( ! fgets(buf, size, fd) ) return (has_data) ? 0 : prelude_error(PRELUDE_ERROR_EOF); len = strlen(buf); if ( ! len ) continue; eol = FALSE; for ( i = len - 1; isspace((int) buf[i]); i-- ) { if ( buf[i] == '\n' || buf[i] == '\r' ) { buf[i] = 0; if ( ! eol ) { eol = TRUE; (*line)++; } } if ( i == 0 ) break; } if ( miss_eol && eol && i == 0 ) continue; /* * We don't want to handle multilines in case this is a comment. */ for ( j = 0; buf[j] != '\0' && isspace((int) buf[j]); j++ ); if ( buf[j] == '#' ) continue; /* * Multiline found, continue reading. */ if ( buf[i] != '\\' ) { if ( eol ) return 0; if ( len == size - 1 ) break; has_data = TRUE; } if ( ! eol ) miss_eol = TRUE; buf += i; size -= i; } return prelude_error_verbose(PRELUDE_ERROR_EINVAL, "buffer is too small to store input line"); }
/** * prelude_client_profile_new: * @ret: Pointer where to store the address of the created object. * @name: Name for this profile. * * Creates a new #prelude_client_profile_t object and store its * address into @ret. * * Returns: 0 on success or a negative value if an error occured. */ int prelude_client_profile_new(prelude_client_profile_t **ret, const char *name) { int retval; prelude_client_profile_t *cp; prelude_return_val_if_fail(name, prelude_error(PRELUDE_ERROR_ASSERTION)); retval = _prelude_client_profile_new(&cp); if ( retval < 0 ) return retval; cp->name = strdup(name); if ( ! cp->name ) { free(cp); return prelude_error_from_errno(errno); } retval = _prelude_client_profile_init(cp); if ( retval < 0 ) return retval; *ret = cp; return 0; }
/** * idmef_time_set_from_timeval: * @time: Pointer to an #idmef_time_t object. * @tv: Pointer to a struct timeval (see gettimeofday()). * * Fills @time object filled with information provided within the @tv structure. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_set_from_timeval(idmef_time_t *time, const struct timeval *tv) { int ret; long gmtoff; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(tv, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = prelude_get_gmt_offset_from_time((const time_t *) &tv->tv_sec, &gmtoff); if ( ret < 0 ) return ret; time->sec = tv->tv_sec; time->usec = tv->tv_usec; time->gmt_offset = (int32_t) gmtoff; return 0; }
/** * idmef_time_set_from_string: * @time: Pointer to an #idmef_time_t object. * @buf: Pointer to a string describing a time in an IDMEF conforming format. * * Fills @time object with information retrieved from the user provided * @buf, containing a string describing a time in a format conforming * to the IDMEF definition (v. 0.10, section 3.2.6). * * Additionally, the provided time might be separated with white spaces, * instead of the IDMEF defined 'T' character. * * If there is no UTC offset specified, we assume that the provided * time is local, and compute the GMT offset by ourselve. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_set_from_string(idmef_time_t *time, const char *buf) { int ret; char *ptr; struct tm tm; prelude_bool_t miss_gmt = FALSE; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); memset(&tm, 0, sizeof(tm)); tm.tm_isdst = -1; ptr = parse_time_ymd(&tm, buf); if ( ! ptr ) return prelude_error_verbose(PRELUDE_ERROR_GENERIC, "error parsing date field, format should be: YY-MM-DD"); time->usec = 0; time->gmt_offset = 0; if ( *ptr ) { ret = parse_time_hmsu(&tm, &time->usec, &ptr); if ( ret < 0 ) return ret; miss_gmt = TRUE; if ( *ptr ) { ret = parse_time_gmt(&tm, &time->gmt_offset, ptr); if ( ret < 0 ) return prelude_error_verbose(PRELUDE_ERROR_GENERIC, "error parsing GMT offset field (Z)?(+|-)?HH:MM"); miss_gmt = FALSE; } } if ( miss_gmt ) { long gmtoff; prelude_get_gmt_offset_from_tm(&tm, &gmtoff); time->gmt_offset = (int32_t) gmtoff; } time->sec = miss_gmt ? mktime(&tm) : prelude_timegm(&tm); return 0; }
/** * prelude_string_vprintf: * @string: Pointer to a #prelude_string_t object. * @fmt: Format string to use. * @ap: Variable argument list. * * Produce output according to @fmt, storing argument provided in @ap * variable argument list, and write the output to the given @string. * See sprintf(3) for more information on @fmt format. * * Returns: The number of characters written, or a negative value if an error occured. */ int prelude_string_vprintf(prelude_string_t *string, const char *fmt, va_list ap) { int ret; va_list bkp; prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(fmt, prelude_error(PRELUDE_ERROR_ASSERTION)); if ( ! (string->flags & PRELUDE_STRING_OWN_DATA) ) { ret = allocate_more_chunk_if_needed(string, 0); if ( ret < 0 ) return ret; } PRELUDE_VA_COPY(bkp, ap); ret = vsnprintf(string->data.rwbuf + string->index, string->size - string->index, fmt, ap); /* * From sprintf(3) on GNU/Linux: * * snprintf and vsnprintf do not write more than * size bytes (including the trailing '\0'), and return -1 if * the output was truncated due to this limit. (Thus until * glibc 2.0.6. Since glibc 2.1 these functions follow the * C99 standard and return the number of characters (exclud- * ing the trailing '\0') which would have been written to * the final string if enough space had been available.) */ if ( ret >= 0 && (size_t) ret < string->size - string->index ) { string->index += ret; goto end; } ret = allocate_more_chunk_if_needed(string, (ret < 0) ? 0 : ret + 1); if ( ret < 0 ) goto end; ret = prelude_string_vprintf(string, fmt, bkp); end: va_end(bkp); return ret; }
/** * prelude_string_set_dup_fast: * @string: Pointer to a #prelude_string_t object. * @buf: String to store in @string. * @len: Lenght of @buf. * * Store a copy of the string pointed by @buf in @string. * The @buf copy will be freed upon prelude_string_destroy(). * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_set_dup_fast(prelude_string_t *string, const char *buf, size_t len) { int ret; prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); STRING_RETURN_IF_INVALID(buf, len); prelude_string_destroy_internal(string); ret = string_buf_alloc(string, len); if ( ret < 0 ) return ret; string_buf_copy(string, buf, len); string->flags |= PRELUDE_STRING_OWN_DATA; return 0; }
int _prelude_client_profile_init(prelude_client_profile_t *cp) { int ret; prelude_return_val_if_fail(cp, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = get_profile_analyzerid(cp); if ( ret < 0 ) return ret; return 0; }
/** * idmef_time_clone: * @src: Pointer to a #idmef_time_t to clone. * @dst: Address where to store the cloned @src object. * * Clones @src and stores the result in the @dst address. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_clone(const idmef_time_t *src, idmef_time_t **dst) { int ret; prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = idmef_time_new(dst); if ( ret < 0 ) return ret; return idmef_time_copy(src, *dst); }
/** * idmef_time_new_from_timeval: * @time: Address where to store the created #idmef_time_t object. * @tv: Pointer to a struct timeval (see gettimeofday()). * * Creates an #idmef_time_t object filled with information provided * within the @tv structure. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_new_from_timeval(idmef_time_t **time, const struct timeval *tv) { int ret; prelude_return_val_if_fail(tv, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = idmef_time_new(time); if ( ret < 0 ) return ret; return idmef_time_set_from_timeval(*time, tv); }
/** * prelude_string_truncate: * @string: Pointer to a #prelude_string_t object. * @len: New @string size * * Truncate @string content. */ int prelude_string_truncate(prelude_string_t *string, size_t len) { int ret; prelude_return_val_if_fail(string, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(len <= string->index, prelude_error(PRELUDE_ERROR_ASSERTION)); if ( len && ! (string->flags & PRELUDE_STRING_OWN_DATA) ) { ret = make_string_own(string, 0); if ( ret < 0 ) return ret; } if ( string->data.rwbuf ) *(string->data.rwbuf + len) = '\0'; else string->data.robuf = NULL; string->index = len; return 0; }
/** * prelude_string_copy_dup: * @src: Pointer to a #prelude_string_t object to copy data from. * @dst: Pointer to a #prelude_string_t object to copy data to. * * Copy @src content within @dst. * The content is owned by @src and independent of @dst. * * Returns: 0 on success, or a negative value if an error occured. */ int prelude_string_copy_dup(const prelude_string_t *src, prelude_string_t *dst) { prelude_return_val_if_fail(src, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(dst, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_string_destroy_internal(dst); dst->size = src->size; dst->index = src->index; dst->flags |= PRELUDE_STRING_OWN_DATA; if ( src->size ) { dst->data.rwbuf = malloc(src->size); if ( ! dst->data.rwbuf ) return prelude_error_from_errno(errno); string_buf_copy(dst, src->data.robuf, src->index); } return 0; }
/** * idmef_time_set_from_gettimeofday: * @time: Pointer to an #idmef_time_t object. * * Fills @time with information retrieved using gettimeofday(). * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_set_from_gettimeofday(idmef_time_t *time) { int ret; struct timeval tv; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = gettimeofday(&tv, NULL); if ( ret < 0 ) return prelude_error_from_errno(errno); return idmef_time_set_from_timeval(time, &tv); }
/** * idmef_time_to_string: * @time: Pointer to an IDMEF time structure. * @out: Pointer to a #prelude_string_t output buffer. * * Translates @time to an user readable string conforming to the IDMEF * defined time format. * * Returns: number of bytes written on success, a negative value if an error occured. */ int idmef_time_to_string(const idmef_time_t *time, prelude_string_t *out) { time_t t; struct tm utc; uint32_t hour_off, min_off; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(out, prelude_error(PRELUDE_ERROR_ASSERTION)); t = time->sec + time->gmt_offset; if ( ! gmtime_r((const time_t *) &t, &utc) ) return prelude_error_from_errno(errno); hour_off = time->gmt_offset / 3600; min_off = time->gmt_offset % 3600 / 60; return prelude_string_sprintf(out, "%d-%.2d-%.2dT%.2d:%.2d:%.2d.%02u%+.2d:%.2d", utc.tm_year + 1900, utc.tm_mon + 1, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec, idmef_time_get_usec(time), hour_off, min_off); }
/** * idmef_time_new_from_time: * @time: Address where to store the created #idmef_time_t object. * @t: Pointer to a time_t. * * Creates a new #idmef_time_t object and store it in @time. * This object will be filled with information available in @t. The created * @time won't contain micro seconds information, since theses are not * available within @t. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_new_from_time(idmef_time_t **time, const time_t *t) { int ret; prelude_return_val_if_fail(t, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = idmef_time_new(time); if ( ret < 0 ) return ret; idmef_time_set_from_time(*time, t); return 0; }
/** * idmef_time_to_ntpstamp: * @time: Pointer to an IDMEF time structure. * @out: Pointer to a #prelude_string_t output buffer. * * Translates @time to an user readable NTP timestamp string, * conforming to the IDMEF defined time format. * * Returns: number of bytes written on success, a negative value if an error occured. */ int idmef_time_to_ntpstamp(const idmef_time_t *time, prelude_string_t *out) { l_fp ts; struct timeval tv; unsigned ts_mask = TS_MASK; /* defaults to 20 bits (us) */ unsigned ts_roundbit = TS_ROUNDBIT; /* defaults to 20 bits (us) */ int ret; prelude_return_val_if_fail(time, prelude_error(PRELUDE_ERROR_ASSERTION)); prelude_return_val_if_fail(out, prelude_error(PRELUDE_ERROR_ASSERTION)); tv.tv_sec = idmef_time_get_sec(time); tv.tv_usec = idmef_time_get_usec(time); sTVTOTS(&tv, &ts); ts.l_ui += JAN_1970; /* make it time since 1900 */ ts.l_uf += ts_roundbit; ts.l_uf &= ts_mask; ret = prelude_string_sprintf(out, "0x%08lx.0x%08lx", (unsigned long) ts.l_ui, (unsigned long) ts.l_uf); return ret; }
/** * prelude_string_new_ref_fast: * @string: Pointer where to store the created #prelude_string_t object. * @str: Initial string value. * @len: Length of @str. * * Create a new #prelude_string_t object with a reference to @str as * initial value. @str won't be freed upon prelude_string_destroy(). * * Returns: 0 on success, a negative value if an error occured. */ int prelude_string_new_ref_fast(prelude_string_t **string, const char *buf, size_t len) { int ret; prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); STRING_RETURN_IF_INVALID(buf, len); ret = prelude_string_new(string); if ( ret < 0 ) return ret; (*string)->index = len; (*string)->size = len + 1; (*string)->data.robuf = buf; return 0; }
/** * idmef_time_new_from_ntpstamp: * @time: Address where to store the created #idmef_time_t object. * @buf: Pointer to a string containing an NTP timestamp. * * Creates an #idmef_time_t object filled with information provided * from the @buf NTP timestamp, and stores it in @time. * * Returns: 0 on success, a negative value if an error occured. */ int idmef_time_new_from_ntpstamp(idmef_time_t **time, const char *buf) { int ret; prelude_return_val_if_fail(buf, prelude_error(PRELUDE_ERROR_ASSERTION)); ret = idmef_time_new(time); if ( ret < 0 ) return ret; ret = idmef_time_set_from_ntpstamp(*time, buf); if ( ret < 0 ) { free(*time); return ret; } return 0; }