/**
* 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;
}
