From: Paul Park Date: Mon, 31 Jul 1995 20:00:32 +0000 (+0000) Subject: Add new string conversion routines X-Git-Tag: krb5-1.0-beta6~1460 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=681293e8be4e68ca81a72d3d7f84ee403002d5bd;p=krb5.git Add new string conversion routines git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@6360 dc483132-0cff-0310-8789-dd5450dbe970 --- diff --git a/src/lib/kadm/Makefile.in b/src/lib/kadm/Makefile.in index 626f3e189..c3bac9144 100644 --- a/src/lib/kadm/Makefile.in +++ b/src/lib/kadm/Makefile.in @@ -8,7 +8,8 @@ BASE_OBJS= adm_conn.$(OBJEXT) \ adm_kt_dec.$(OBJEXT) \ adm_kt_enc.$(OBJEXT) \ adm_rw.$(OBJEXT) \ - alt_prof.$(OBJEXT) + alt_prof.$(OBJEXT) \ + str_conv.$(OBJEXT) UNIX_OBJS = logger.$(OBJEXT) @@ -24,7 +25,8 @@ SRCS= $(srcdir)/adm_conn.c \ $(srcdir)/adm_kw_dec.c \ $(srcdir)/adm_kw_enc.c \ $(srcdir)/logger.c \ - $(srcdir)/alt_prof.c + $(srcdir)/alt_prof.c \ + $(srcdir)/str_conv.c all:: all-$(WHAT) $(BASE_OBJS) @@ -54,8 +56,9 @@ clean-windows:: # t_dbentry # T_DBENTRY_OBJS = t_dbentry.$(OBJEXT) \ - $(TOPLIBD)/libkadm.a $(TOPLIBD)/libkrb5.a \ - $(TOPLIBD)/libcrypto.a $(TOPLIBD)/libcom_err.a + $(TOPLIBD)/libkadm.a $(TOPLIBD)/libkdb5.a \ + $(TOPLIBD)/libkrb5.a $(TOPLIBD)/libcrypto.a \ + $(TOPLIBD)/libcom_err.a t_dbentry: $(T_DBENTRY_OBJS) $(LD) -o t_dbentry $(T_DBENTRY_OBJS) $(LIBS) diff --git a/src/lib/kadm/configure.in b/src/lib/kadm/configure.in index b5e674b7a..d89fb3e9d 100644 --- a/src/lib/kadm/configure.in +++ b/src/lib/kadm/configure.in @@ -5,7 +5,7 @@ AC_PROG_ARCHIVE_ADD AC_PROG_RANLIB AC_PROG_INSTALL AC_HAVE_HEADERS(pwd.h stdarg.h syslog.h) -AC_HAVE_FUNCS(srand48 srand srandom syslog openlog closelog strftime) +AC_HAVE_FUNCS(srand48 srand srandom syslog openlog closelog strftime strptime) AC_FUNC_CHECK(vsprintf,AC_DEFINE(HAVE_VSPRINTF)) ET_RULES LinkFileDir(../libkadm.a, libkadm.a, ./kadm) diff --git a/src/lib/kadm/str_conv.c b/src/lib/kadm/str_conv.c new file mode 100644 index 000000000..b925f78b3 --- /dev/null +++ b/src/lib/kadm/str_conv.c @@ -0,0 +1,824 @@ +/* + * lib/kadm/str_conv.c + * + * Copyright 1995 by the Massachusetts Institute of Technology. + * All Rights Reserved. + * + * Export of this software from the United States of America may + * require a specific license from the United States Government. + * It is the responsibility of any person or organization contemplating + * export to obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and + * distribute this software and its documentation for any purpose and + * without fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright notice and + * this permission notice appear in supporting documentation, and that + * the name of M.I.T. not be used in advertising or publicity pertaining + * to distribution of the software without specific, written prior + * permission. M.I.T. makes no representations about the suitability of + * this software for any purpose. It is provided "as is" without express + * or implied warranty. + * + */ + +/* + * str_conv.c - Convert between strings and Kerberos internal data. + */ + +/* + * Table of contents: + * + * String decoding: + * ---------------- + * krb5_string_to_keytype() - Convert string to krb5_keytype. + * krb5_string_to_salttype() - Convert string to salttype (krb5_int32) + * krb5_string_to_enctype() - Convert string to krb5_enctype. + * krb5_string_to_cksumtype() - Convert string to krb5_cksumtype; + * krb5_string_to_flags() - Convert string to krb5_flags. + * krb5_string_to_timestamp() - Convert string to krb5_timestamp. + * krb5_string_to_deltat() - Convert string to krb5_deltat. + * + * String encoding: + * ---------------- + * krb5_keytype_to_string() - Convert krb5_keytype to string. + * krb5_salttype_to_string() - Convert salttype (krb5_int32) to string. + * krb5_enctype_to_string() - Convert krb5_enctype to string. + * krb5_cksumtype_to_string() - Convert krb5_cksumtype to string. + * krb5_flags_to_string() - Convert krb5_flags to string. + * krb5_timestamp_to_string() - Convert krb5_timestamp to string. + * krb5_deltat_to_string() - Convert krb5_deltat to string. + */ + +#include "k5-int.h" +#include "adm.h" +#include "adm_proto.h" + +/* + * Local data structures. + */ +struct keytype_lookup_entry { + krb5_keytype ktt_keytype; /* Keytype */ + const char * ktt_specifier; /* How to recognize it */ + const char * ktt_output; /* How to spit it out */ +}; + +struct salttype_lookup_entry { + krb5_int32 stt_keytype; /* Salt type */ + const char * stt_specifier; /* How to recognize it */ + const char * stt_output; /* How to spit it out */ +}; + +struct enctype_lookup_entry { + krb5_enctype ett_enctype; /* Encryption type */ + const char * ett_specifier; /* How to recognize it */ + const char * ett_output; /* How to spit it out */ +}; + +struct cksumtype_lookup_entry { + krb5_cksumtype cst_cksumtype; /* Checksum type */ + const char * cst_specifier; /* How to recognize it */ + const char * cst_output; /* How to spit it out */ +}; + +struct flags_lookup_entry { + krb5_flags fl_flags; /* Flag */ + krb5_boolean fl_sense; /* Sense of the flag */ + const char * fl_specifier; /* How to recognize it */ + const char * fl_output; /* How to spit it out */ +}; + +struct deltat_match_entry { + const char * dt_scan_format; /* sscanf format */ + int dt_nmatch; /* Number to match */ + int dt_dindex; /* Day index */ + int dt_hindex; /* Hour index */ + int dt_mindex; /* Minute index */ + int dt_sindex; /* Second index */ +}; + +/* + * Local strings + */ +/* Keytype strings */ +static const char keytype_null_in[] = "null"; +static const char keytype_des_in[] = "des"; +static const char keytype_null_out[] = "Null"; +static const char keytype_des_out[] = "DES"; + +/* Salttype strings */ +static const char stype_v5_in[] = "normal"; +static const char stype_v4_in[] = "v4"; +static const char stype_norealm_in[] = "norealm"; +static const char stype_olrealm_in[] = "onlyrealm"; +static const char stype_special_in[] = "special"; +static const char stype_v5_out[] = "Version 5"; +static const char stype_v4_out[] = "Version 4"; +static const char stype_norealm_out[] = "Version 5 - No Realm"; +static const char stype_olrealm_out[] = "Version 5 - Realm Only"; +static const char stype_special_out[] = "Special"; + +/* Encryption type strings */ +static const char etype_null_in[] = "null"; +static const char etype_descbccrc_in[] = "des-cbc-crc"; +static const char etype_descbcmd4_in[] = "des-cbc-md4"; +static const char etype_descbcmd5_in[] = "des-cbc-md5"; +static const char etype_rawdescbc_in[] = "raw-des-cbc"; +static const char etype_null_out[] = "Null"; +static const char etype_descbccrc_out[] = "DES cbc mode with CRC-32"; +static const char etype_descbcmd4_out[] = "DES cbc mode with RSA-MD4"; +static const char etype_descbcmd5_out[] = "DES cbc mode with RSA-MD5"; +static const char etype_rawdescbc_out[] = "DES cbc mode"; + +/* Checksum type strings */ +static const char cstype_crc32_in[] = "crc32"; +static const char cstype_md4_in[] = "md4"; +static const char cstype_md4des_in[] = "md4-des"; +static const char cstype_descbc_in[] = "des-cbc"; +static const char cstype_md5_in[] = "md5"; +static const char cstype_md5des_in[] = "md5-des"; +static const char cstype_crc32_out[] = "CRC-32"; +static const char cstype_md4_out[] = "RSA-MD4"; +static const char cstype_md4des_out[] = "RSA-MD4 with DES cbc mode"; +static const char cstype_descbc_out[] = "DES cbc mode"; +static const char cstype_md5_out[] = "RSA-MD5"; +static const char cstype_md5des_out[] = "RSA-MD5 with DES cbc mode"; + +/* Flags strings */ +static const char flags_pdate_in[] = "postdateable"; +static const char flags_fwd_in[] = "forwardable"; +static const char flags_tgtbased_in[] = "tgt-based"; +static const char flags_renew_in[] = "renewable"; +static const char flags_proxy_in[] = "proxiable"; +static const char flags_dup_skey_in[] = "dup-skey"; +static const char flags_tickets_in[] = "allow-tickets"; +static const char flags_preauth_in[] = "preauth"; +static const char flags_hwauth_in[] = "hwauth"; +static const char flags_pwchange_in[] = "pwchange"; +static const char flags_service_in[] = "service"; +static const char flags_pwsvc_in[] = "pwservice"; +static const char flags_md5_in[] = "md5"; +static const char flags_pdate_out[] = "Not Postdateable"; +static const char flags_fwd_out[] = "Not Forwardable"; +static const char flags_tgtbased_out[] = "No TGT-based requests"; +static const char flags_renew_out[] = "Not renewable"; +static const char flags_proxy_out[] = "Not proxiable"; +static const char flags_dup_skey_out[] = "No DUP_SKEY requests"; +static const char flags_tickets_out[] = "All Tickets Disallowed"; +static const char flags_preauth_out[] = "Preauthorization required"; +static const char flags_hwauth_out[] = "HW Authorization required"; +static const char flags_pwchange_out[] = "Password Change required"; +static const char flags_service_out[] = "Service Disabled"; +static const char flags_pwsvc_out[] = "Password Changing Service"; +static const char flags_md5_out[] = "RSA-MD5 supported"; +static const char flags_default_neg[] = "-"; +static const char flags_default_sep[] = " "; + +/* Absolute time strings */ +static const char atime_full_digits[] = "%y%m%d%H%M%S"; +static const char atime_full_digits_d[] = "%y.%m.%d.%H.%M.%S"; +static const char atime_nsec_digits[] = "%y%m%d%H%M"; +static const char atime_rel_hms[] = "%H%M%S"; +static const char atime_rel_hm[] = "%H%M"; +static const char atime_rel_col_hms[] = "%T"; +static const char atime_rel_col_hm[] = "%R"; +static const char atime_ldep_sfmt[] = "%x:%X"; +static const char atime_full_text[] = "%d-%b-%Y:%T"; +static const char atime_full_text_nos[] = "%d-%b-%Y:%R"; +#if !HAVE_STRPTIME +static const char ascan_full_digits[] = "%02d%02d%02d%02d%02d%02d"; +static const char ascan_full_digits_d[] = "%02d.%02d.%02d.%02d.%02d.%02d"; +static const char ascan_nsec_digits[] = "%02d%02d%02d%02d%02d"; +static const char ascan_rel_hms[] = "%02d%02d%02d"; +static const char ascan_rel_hm[] = "%02d%02d"; +static const char ascan_rel_col_hms[] = "%02d:%02d:%02d"; +static const char ascan_rel_col_hm[] = "%02d:%02d"; +#endif /* !HAVE_STRPTIME */ + +/* Delta time strings */ +static const char dtscan_dhms_notext[] = "%d-%02d:%02d:%02d"; +static const char dtscan_dhms_stext[] = "%dd%dh%dm%ds"; +static const char dtscan_hms_notext[] = "%d:%02d:%02d"; +static const char dtscan_hms_stext[] = "%dh%dm%ds"; +static const char dtscan_hm_notext[] = "%d:%02d"; +static const char dtscan_hm_stext[] = "%dh%dm"; +static const char dtscan_days[] = "%d%[d]"; +static const char dtscan_hours[] = "%d%[h]"; +static const char dtscan_minutes[] = "%d%[m]"; +static const char dtscan_seconds[] = "%d%[s]"; +static const char dt_day_singular[] = "day"; +static const char dt_day_plural[] = "days"; +static const char dt_output_donly[] = "%d %s"; +static const char dt_output_dhms[] = "%d %s %02d:%02d:%02d"; +static const char dt_output_hms[] = "%d:%02d:%02d"; + +/* + * Lookup tables. + */ +static const struct keytype_lookup_entry keytype_table[] = { +/* krb5_keytype input specifier output string */ +/*------------- ----------------------- ------------------------*/ +{ KEYTYPE_NULL, keytype_null_in, keytype_null_out }, +{ KEYTYPE_DES, keytype_des_in, keytype_des_out } +}; +static const int keytype_table_nents = sizeof(keytype_table)/ + sizeof(keytype_table[0]); + +static const struct salttype_lookup_entry salttype_table[] = { +/* salt type input specifier output string */ +/*----------------------------- ----------------------- ------------------*/ +{ KRB5_KDB_SALTTYPE_NORMAL, stype_v5_in, stype_v5_out }, +{ KRB5_KDB_SALTTYPE_V4, stype_v4_in, stype_v4_out }, +{ KRB5_KDB_SALTTYPE_NOREALM, stype_norealm_in, stype_norealm_out }, +{ KRB5_KDB_SALTTYPE_ONLYREALM, stype_olrealm_in, stype_olrealm_out }, +{ KRB5_KDB_SALTTYPE_SPECIAL, stype_special_in, stype_special_out } +}; +static const int salttype_table_nents = sizeof(salttype_table)/ + sizeof(salttype_table[0]); + +static const struct enctype_lookup_entry enctype_table[] = { +/* krb5_enctype input specifier output string */ +/*------------------ --------------------- ------------------------*/ +{ ETYPE_NULL, etype_null_in, etype_null_out }, +{ ETYPE_DES_CBC_CRC, etype_descbccrc_in, etype_descbccrc_out }, +{ ETYPE_DES_CBC_MD4, etype_descbcmd4_in, etype_descbcmd4_out }, +{ ETYPE_DES_CBC_MD5, etype_descbcmd5_in, etype_descbcmd5_out }, +{ ETYPE_RAW_DES_CBC, etype_rawdescbc_in, etype_rawdescbc_out } +}; +static const int enctype_table_nents = sizeof(enctype_table)/ + sizeof(enctype_table[0]); + +static const struct cksumtype_lookup_entry cksumtype_table[] = { +/* krb5_cksumtype input specifier output string */ +/*----------------------- --------------------- ------------------------*/ +{ CKSUMTYPE_CRC32, cstype_crc32_in, cstype_crc32_out }, +{ CKSUMTYPE_RSA_MD4, cstype_md4_in, cstype_md4_out }, +{ CKSUMTYPE_RSA_MD4_DES, cstype_md4des_in, cstype_md4des_out }, +{ CKSUMTYPE_DESCBC, cstype_descbc_in, cstype_descbc_out }, +{ CKSUMTYPE_RSA_MD5, cstype_md5_in, cstype_md5_out }, +{ CKSUMTYPE_RSA_MD5_DES, cstype_md5des_in, cstype_md5des_out } +}; +static const int cksumtype_table_nents = sizeof(cksumtype_table)/ + sizeof(cksumtype_table[0]); + +static const struct flags_lookup_entry flags_table[] = { +/* flag sense input specifier output string */ +/*----------------------------- ------- ------------------ ------------------*/ +{ KRB5_KDB_DISALLOW_POSTDATED, 0, flags_pdate_in, flags_pdate_out }, +{ KRB5_KDB_DISALLOW_FORWARDABLE,0, flags_fwd_in, flags_fwd_out }, +{ KRB5_KDB_DISALLOW_TGT_BASED, 0, flags_tgtbased_in, flags_tgtbased_out}, +{ KRB5_KDB_DISALLOW_RENEWABLE, 0, flags_renew_in, flags_renew_out }, +{ KRB5_KDB_DISALLOW_PROXIABLE, 0, flags_proxy_in, flags_proxy_out }, +{ KRB5_KDB_DISALLOW_DUP_SKEY, 0, flags_dup_skey_in, flags_dup_skey_out}, +{ KRB5_KDB_DISALLOW_ALL_TIX, 0, flags_tickets_in, flags_tickets_out }, +{ KRB5_KDB_REQUIRES_PRE_AUTH, 1, flags_preauth_in, flags_preauth_out }, +{ KRB5_KDB_REQUIRES_HW_AUTH, 1, flags_hwauth_in, flags_hwauth_out }, +{ KRB5_KDB_REQUIRES_PWCHANGE, 1, flags_pwchange_in, flags_pwchange_out}, +{ KRB5_KDB_DISALLOW_SVR, 0, flags_service_in, flags_service_out }, +{ KRB5_KDB_PWCHANGE_SERVICE, 1, flags_pwsvc_in, flags_pwsvc_out }, +{ KRB5_KDB_SUPPORT_DESMD5, 1, flags_md5_in, flags_md5_out } +}; +static const int flags_table_nents = sizeof(flags_table)/ + sizeof(flags_table[0]); + +static const char * const atime_format_table[] = { +atime_full_digits, /* yymmddhhmmss */ +atime_full_digits_d, /* yy.mm.dd.hh.mm.ss */ +atime_nsec_digits, /* yymmddhhmm */ +atime_rel_hms, /* hhmmss */ +atime_rel_hm, /* hhmm */ +atime_rel_col_hms, /* hh:mm:ss */ +atime_rel_col_hm, /* hh:mm */ +/* The following not really supported unless native strptime present */ +atime_ldep_sfmt, /*locale-dependent short format */ +atime_full_text, /* dd-month-yyyy:hh:mm:ss */ +atime_full_text_nos /* dd-month-yyyy:hh:mm */ +}; +static const int atime_format_table_nents = sizeof(atime_format_table)/ + sizeof(atime_format_table[0]); + +static const struct deltat_match_entry deltat_table[] = { +/* scan format nmatch daypos hourpos minpos secpos */ +/*--------------------- ------- ------- ------- ------- --------*/ +{ dtscan_dhms_notext, 4, 0, 1, 2, 3 }, +{ dtscan_dhms_stext, 4, 0, 1, 2, 3 }, +{ dtscan_hms_notext, 3, -1, 0, 1, 2 }, +{ dtscan_hms_stext, 3, -1, 0, 1, 2 }, +{ dtscan_hm_notext, 2, -1, -1, 0, 1 }, +{ dtscan_hm_stext, 2, -1, -1, 0, 1 }, +{ dtscan_days, 2, 0, -1, -1, -1 }, +{ dtscan_hours, 2, -1, 0, -1, -1 }, +{ dtscan_minutes, 2, -1, -1, 0, -1 }, +{ dtscan_seconds, 2, -1, -1, -1, 0 } +}; +static const int deltat_table_nents = sizeof(deltat_table)/ + sizeof(deltat_table[0]); + +#if !HAVE_STRPTIME +/* + * Rudimentary version of strptime for systems which don't have it. + */ +static char * +strptime(buf, format, tm) + char *buf; + const char *format; + struct tm *tm; +{ + int year, month, day, hour, minute, second; + char *bp; + time_t now; + + /* + * We only understand the following fixed formats: + * %y%m%d%H%M%S + * %y.%m.%d.%H.%M.%S + * %y%m%d%H%M + * %H%M%S + * %H%M + * %T + * %R + */ + bp = (char *) NULL; + if (!strcmp(format, atime_full_digits) && + (sscanf(buf, ascan_full_digits, + &year, &month, &day, &hour, &minute, &second) == 6)) { + tm->tm_year = year; + tm->tm_mon = month - 1; + tm->tm_mday = day; + tm->tm_hour = hour; + tm->tm_min = minute; + tm->tm_sec = second; + bp = &buf[strlen(atime_full_digits)]; + } + else if (!strcmp(format,atime_full_digits_d) && + (sscanf(buf, ascan_full_digits_d, + &year, &month, &day, &hour, &minute, &second) == 6)) { + tm->tm_year = year; + tm->tm_mon = month - 1; + tm->tm_mday = day; + tm->tm_hour = hour; + tm->tm_min = minute; + tm->tm_sec = second; + bp = &buf[strlen(atime_full_digits_d)]; + } + else if (!strcmp(format, atime_nsec_digits) && + (sscanf(buf, ascan_nsec_digits, + &year, &month, &day, &hour, &minute) == 5)) { + tm->tm_year = year; + tm->tm_mon = month - 1; + tm->tm_mday = day; + tm->tm_hour = hour; + tm->tm_min = minute; + tm->tm_sec = 0; + bp = &buf[strlen(atime_nsec_digits)]; + } + else if (!strcmp(format, atime_rel_hms) && + (sscanf(buf, ascan_rel_hms, &hour, &minute, &second) == 3)) { + now = time((time_t *) NULL); + memcpy(tm, localtime(&now), sizeof(struct tm)); + tm->tm_hour = hour; + tm->tm_min = minute; + tm->tm_sec = second; + bp = &buf[strlen(atime_rel_hms)]; + } + else if (!strcmp(format, atime_rel_hm) && + (sscanf(buf, ascan_rel_hm, &hour, &minute) == 2)) { + now = time((time_t *) NULL); + memcpy(tm, localtime(&now), sizeof(struct tm)); + tm->tm_hour = hour; + tm->tm_min = minute; + bp = &buf[strlen(atime_rel_hm)]; + } + else if (!strcmp(format, atime_rel_col_hms) && + (sscanf(buf, ascan_rel_col_hms, &hour, &minute, &second) == 3)) { + now = time((time_t *) NULL); + memcpy(tm, localtime(&now), sizeof(struct tm)); + tm->tm_hour = hour; + tm->tm_min = minute; + tm->tm_sec = second; + bp = &buf[strlen(atime_rel_col_hms)]; + } + else if (!strcmp(format, atime_rel_col_hm) && + (sscanf(buf, ascan_rel_col_hm, &hour, &minute) == 2)) { + now = time((time_t *) NULL); + memcpy(tm, localtime(&now), sizeof(struct tm)); + tm->tm_hour = hour; + tm->tm_min = minute; + bp = &buf[strlen(atime_rel_col_hm)]; + } + return(bp); +} +#endif /* HAVE_STRPTIME */ + +/* + * String to internal datatype routines. + * + * These routines return 0 for success, EINVAL for invalid entry. + */ +krb5_error_code +krb5_string_to_keytype(string, keytypep) + char * string; + krb5_keytype * keytypep; +{ + int i; + int found; + + found = 0; + for (i=0; i= 0) + days = svalues[deltat_table[i].dt_dindex]; + if (deltat_table[i].dt_hindex >= 0) + hours = svalues[deltat_table[i].dt_hindex]; + if (deltat_table[i].dt_mindex >= 0) + minutes = svalues[deltat_table[i].dt_mindex]; + if (deltat_table[i].dt_sindex >= 0) + seconds = svalues[deltat_table[i].dt_sindex]; + found = 1; + break; + } + } + if (found) { + dt = days; + dt *= 24; + dt += hours; + dt *= 60; + dt += minutes; + dt *= 60; + dt += seconds; + *deltatp = dt; + } + return((found) ? 0 : EINVAL); +} + +/* + * Internal datatype to string routines. + * + * These routines return 0 for success, EINVAL for invalid parameter, ENOMEM + * if the supplied buffer/length will not contain the output. + */ +krb5_error_code +krb5_keytype_to_string(keytype, buffer, buflen) + krb5_keytype keytype; + char * buffer; + size_t buflen; +{ + int i; + const char *out; + + out = (char *) NULL; + for (i=0; i strlen(out)) + strcpy(buffer, out); + else + out = (char *) NULL; + return((out) ? 0 : ENOMEM); + } + else + return(EINVAL); +} + +krb5_error_code +krb5_salttype_to_string(salttype, buffer, buflen) + krb5_int32 salttype; + char * buffer; + size_t buflen; +{ + int i; + const char *out; + + out = (char *) NULL; + for (i=0; i strlen(out)) + strcpy(buffer, out); + else + out = (char *) NULL; + return((out) ? 0 : ENOMEM); + } + else + return(EINVAL); +} + +krb5_error_code +krb5_enctype_to_string(enctype, buffer, buflen) + krb5_enctype enctype; + char * buffer; + size_t buflen; +{ + int i; + const char *out; + + out = (char *) NULL; + for (i=0; i strlen(out)) + strcpy(buffer, out); + else + out = (char *) NULL; + return((out) ? 0 : ENOMEM); + } + else + return(EINVAL); +} + +krb5_error_code +krb5_cksumtype_to_string(cksumtype, buffer, buflen) + krb5_cksumtype cksumtype; + char * buffer; + size_t buflen; +{ + int i; + const char *out; + + out = (char *) NULL; + for (i=0; i strlen(out)) + strcpy(buffer, out); + else + out = (char *) NULL; + return((out) ? 0 : ENOMEM); + } + else + return(EINVAL); +} + +krb5_error_code +krb5_flags_to_string(flags, sep, buffer, buflen) + krb5_flags flags; + const char * sep; + char * buffer; + size_t buflen; +{ + int i; + krb5_flags pflags; + const char *sepstring; + char *op; + int initial; + krb5_error_code retval; + + retval = 0; + op = buffer; + pflags = 0; + initial = 1; + sepstring = (sep) ? sep : flags_default_sep; + /* Blast through the table matching all we can */ + for (i=0; i\n\0 */ + buffer[strlen(buffer)-1] = '\0'; + return(0); + } + return(ENOMEM); +} + +krb5_error_code +krb5_deltat_to_string(deltat, buffer, buflen) + krb5_deltat deltat; + char * buffer; + size_t buflen; +{ + int days, hours, minutes, seconds; + krb5_deltat dt; + krb5_error_code retval; + + days = deltat / (24*3600); + dt = deltat % (24*3600); + hours = dt / 3600; + dt %= 3600; + minutes = dt / 60; + seconds = dt % 60; + + retval = 0; + if (days) { + if (hours || minutes || seconds) { + if (buflen < (strlen(dt_output_dhms)+strlen(dt_day_plural))) + retval = ENOMEM; + else + sprintf(buffer, dt_output_dhms, days, + (days > 1) ? dt_day_plural : dt_day_singular, + hours, minutes, seconds); + } + else { + if (buflen < (strlen(dt_output_donly)+strlen(dt_day_plural))) + retval = ENOMEM; + else + sprintf(buffer, dt_output_donly, days, + (days > 1) ? dt_day_plural : dt_day_singular); + } + } + else { + if (buflen < strlen(dt_output_hms)) + retval = ENOMEM; + else + sprintf(buffer, dt_output_hms, hours, minutes, seconds); + } + return(retval); +}