coding style and updated coding test (not all files are checked)

diff --git a/host2str.c b/host2str.c
index ae9ba3208621cc06973e4a964bb323b0e6ca8bf1..24d25ded50f12d09d2a5f7d255fed9dffc1c6ee0 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -110,13 +110,13 @@ ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
                                   characters in dnames
                                */
                                if (data[src_pos] == '.' ||
-                                   data[src_pos] == '(' ||
-                                   data[src_pos] == ')')
-                               {
-                                       ldns_buffer_printf(output, "\\%c", data[src_pos]);
+                                   data[src_pos] == '(' || data[src_pos] == ')') {
+                                       ldns_buffer_printf(output, "\\%c", 
+                                                       data[src_pos]);
                                        /* isprint!? */
                                } else if (!isprint((int) data[src_pos])) {
-                                       ldns_buffer_printf(output, "\\%03u", data[src_pos]);
+                                       ldns_buffer_printf(output, "\\%03u", 
+                                                       data[src_pos]);
                                } else {
                                        ldns_buffer_printf(output, "%c", data[src_pos]);
                                }
@@ -167,8 +167,7 @@ ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
        memcpy(&data_time, &data, sizeof(uint32_t));
        memset(&tm, 0, sizeof(tm));
 
-       if (gmtime_r(&data_time, &tm) &&
-           strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
+       if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
                ldns_buffer_printf(output, "%s", date_buf);
        }
        return ldns_buffer_status(output);
@@ -436,17 +435,14 @@ ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
        endprotoent();
        
        for (current_service = 0; 
-            current_service < ldns_rdf_size(rdf) * 7;
-            current_service++) {
+            current_service < ldns_rdf_size(rdf) * 7; current_service++) {
                if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
                        service = getservbyport((int) ntohs(current_service),
                                                proto_name);
                        if (service && service->s_name) {
-                               ldns_buffer_printf(output, "%s ", 
-                                                  service->s_name);
+                               ldns_buffer_printf(output, "%s ", service->s_name);
                        } else {
-                               ldns_buffer_printf(output, "%u ",
-                                                  current_service);
+                               ldns_buffer_printf(output, "%u ", current_service);
                        }
                        endservent();
                }
@@ -479,7 +475,8 @@ ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
                                descriptor = ldns_rr_descript(type);
 
                                if (descriptor->_name) {
-                                       ldns_buffer_printf(output, "%s ", descriptor->_name);
+                                       ldns_buffer_printf(output, "%s ", 
+                                                       descriptor->_name);
                                } else {
                                        ldns_buffer_printf(output, "TYPE%d ", type);
                                }
@@ -579,7 +576,8 @@ ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
                
                } else {
                        /* unknown address family */
-                       ldns_buffer_printf(output, "Unknown address family: %u data: ", address_family);
+                       ldns_buffer_printf(output, "Unknown address family: %u data: ", 
+                                       address_family);
                        for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
                                ldns_buffer_printf(output, "%02x", data[i]);
                        }
@@ -640,14 +638,13 @@ ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
                case 1:
                        gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
                        memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
-                       gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, 
-                                       LDNS_IP4ADDRLEN , gateway_data);
+                       gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
                        break;
                case 2:
                        gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
                        memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
-                       gateway = ldns_rdf_new(LDNS_RDF_TYPE_AAAA, 
-                                       LDNS_IP6ADDRLEN, gateway_data);
+                       gateway = 
+                               ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
                        break;
                case 3:
                        status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
@@ -662,8 +659,7 @@ ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
        memcpy(public_key_data, &data[offset], public_key_size);
        public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
        
-       ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type,
-                          algorithm);
+       ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
        (void) ldns_rdf2buffer_str(output, gateway);
        ldns_buffer_printf(output, " ");
        (void) ldns_rdf2buffer_str(output, public_key); 
@@ -805,7 +801,8 @@ ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
                if (lt) {
                        ldns_buffer_printf(output, "\t%s\t", lt->name);
                } else {
-                       ldns_buffer_printf(output, "\tCLASS%d\t", ldns_rr_get_class(rr));
+                       ldns_buffer_printf(output, "\tCLASS%d\t", 
+                                       ldns_rr_get_class(rr));
                }
 
                descriptor = ldns_rr_descript(ldns_rr_get_type(rr));
@@ -825,7 +822,8 @@ ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
                        } else if (ldns_rr_get_type(rr) == 255) {
                                ldns_buffer_printf(output, "ANY ");
                        } else {
-                               ldns_buffer_printf(output, "TYPE%d\t", ldns_rr_get_type(rr));
+                               ldns_buffer_printf(output, "TYPE%d\t", 
+                                               ldns_rr_get_type(rr));
                        }
                }
                
@@ -846,13 +844,15 @@ ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
                                case LDNS_RR_TYPE_DNSKEY:
 #ifdef HAVE_SSL
                                        if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 256) {
-                                               ldns_buffer_printf(output, " ;{id = %d (zsk), size = %db}", 
+                                               ldns_buffer_printf(output, 
+                                                               " ;{id = %d (zsk), size = %db}", 
                                                                ldns_calc_keytag(rr),
                                                                ldns_rr_dnskey_key_size(rr)); 
                                                break;
                                        } 
                                        if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 257) {
-                                               ldns_buffer_printf(output, " ;{id = %d (ksk), size = %db}", 
+                                               ldns_buffer_printf(output, 
+                                                               " ;{id = %d (ksk), size = %db}", 
                                                                ldns_calc_keytag(rr),
                                                                ldns_rr_dnskey_key_size(rr)); 
                                                break;
@@ -900,7 +900,8 @@ ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
        if (opcode) {
                ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
        } else {
-               ldns_buffer_printf(output, "opcode: ?? (%u), ", ldns_pkt_get_opcode(pkt));
+               ldns_buffer_printf(output, "opcode: ?? (%u), ", 
+                               ldns_pkt_get_opcode(pkt));
        }
        if (rcode) {
                ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
@@ -1005,22 +1006,22 @@ ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
                }
                ldns_buffer_printf(output, "\n");
                /* add some futher fields */
-               ldns_buffer_printf(output, ";; Query time: %d msec\n", ldns_pkt_querytime(pkt));
+               ldns_buffer_printf(output, ";; Query time: %d msec\n", 
+                               ldns_pkt_querytime(pkt));
                if (ldns_pkt_edns(pkt)) {
                        ldns_buffer_printf(output,
-                                          ";; EDNS: version %u; flags:",
-                                          ldns_pkt_edns_version(pkt)
-                                         );
+                                  ";; EDNS: version %u; flags:", 
+                                  ldns_pkt_edns_version(pkt));
                        if (ldns_pkt_edns_do(pkt)) {
                                ldns_buffer_printf(output, " do");
                        }
                        ldns_buffer_printf(output, " ; udp: %u\n",
-                                          ldns_pkt_edns_udp_size(pkt)
-                                         );
+                                          ldns_pkt_edns_udp_size(pkt));
                        
                        if (ldns_pkt_edns_data(pkt)) {
                                ldns_buffer_printf(output, ";; Data: ");
-                               (void)ldns_rdf2buffer_str(output, ldns_pkt_edns_data(pkt));
+                               (void)ldns_rdf2buffer_str(output, 
+                                                         ldns_pkt_edns_data(pkt));
                                ldns_buffer_printf(output, "\n");
                        }
                }
@@ -1035,9 +1036,11 @@ ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
                        LDNS_FREE(tmp);
                }
                time = ldns_pkt_timestamp(pkt);
-               ldns_buffer_printf(output, ";; WHEN: %s", (char*)ctime((time_t*)&time));
+               ldns_buffer_printf(output, ";; WHEN: %s", 
+                               (char*)ctime((time_t*)&time));
 
-               ldns_buffer_printf(output, ";; MSG SIZE  rcvd: %d\n", (int)ldns_pkt_size(pkt));
+               ldns_buffer_printf(output, ";; MSG SIZE  rcvd: %d\n", 
+                               (int)ldns_pkt_size(pkt));
        } else {
                return ldns_buffer_status(output);
        }
@@ -1423,7 +1426,8 @@ ldns_resolver_print(FILE *output, const ldns_resolver *r)
        fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
        
        fprintf(output, "default domain:");
-       ldns_rdf_print(output, ldns_resolver_domain(r)); fprintf(output, "\n");
+       ldns_rdf_print(output, ldns_resolver_domain(r)); 
+       fprintf(output, "\n");
 
        fprintf(output, "nameservers:\n");
        for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {

diff --git a/rdata.c b/rdata.c
index a6cb75ccdc4187f6a9113c09400e224807c06135..8168c44949afda3b20c3bfbe4ec99025179f92b9 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -190,10 +190,8 @@ ldns_rdf *
 ldns_rdf_clone(const ldns_rdf *rd)
 {
        assert(rd != NULL);
-       return (ldns_rdf_new_frm_data(
-                               ldns_rdf_get_type(rd),
-                               ldns_rdf_size(rd), 
-                               ldns_rdf_data(rd)));
+       return (ldns_rdf_new_frm_data( ldns_rdf_get_type(rd),
+               ldns_rdf_size(rd), ldns_rdf_data(rd)));
 }
 
 void
@@ -369,10 +367,8 @@ ldns_rdf_address_reverse(ldns_rdf *rd)
                                return NULL;
                        }
                        /* make a new rdf and convert that back  */
-                       rev = ldns_rdf_new_frm_data(
-                                       LDNS_RDF_TYPE_A,
-                                       LDNS_IP4ADDRLEN,
-                                       (void*)&buf_4);
+                       rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A,
+                               LDNS_IP4ADDRLEN, (void*)&buf_4);
 
                        /* convert rev to a string */
                        char_dname = ldns_rdf2str(rev);
@@ -397,9 +393,13 @@ ldns_rdf_address_reverse(ldns_rdf *rd)
                                /* calculate nibble */
                                nnibble = ( ((unsigned int) nbit) & 0x04) >> 2;
                                /* extract nibble */
-                               nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 - nnibble)) ) ) >> ( 4 * (1 - nnibble));
+                               nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 -
+                                                nnibble)) ) ) >> ( 4 * (1 - 
+                                               nnibble));
+
                                buf_6[(LDNS_IP6ADDRLEN * 2 - 1) -
-                                       (octet * 2 + nnibble)] = (uint8_t)ldns_int_to_hexdigit((int)nibble);
+                                       (octet * 2 + nnibble)] = 
+                                               (uint8_t)ldns_int_to_hexdigit((int)nibble);
                        }
 
                        char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
@@ -441,7 +441,8 @@ ldns_rdf_address_reverse(ldns_rdf *rd)
 ldns_status
 ldns_octet(char *word, size_t *length)
 {
-    char *s; char *p;
+    char *s; 
+    char *p;
     *length = 0;
 
     for (s = p = word; *s != '\0'; s++,p++) {
@@ -456,8 +457,7 @@ ldns_octet(char *word, size_t *length)
             case '\\':
                 if ('0' <= s[1] && s[1] <= '9' &&
                     '0' <= s[2] && s[2] <= '9' &&
-                    '0' <= s[3] && s[3] <= '9')
-                {
+                    '0' <= s[3] && s[3] <= '9') {
                     /* \DDD seen */
                     int val = ((s[1] - '0') * 100 +
                            (s[2] - '0') * 10 + (s[3] - '0'));

diff --git a/rr.c b/rr.c
index 4d97e4af7a3c05e7dabdf99d75cfe13d2f106c5b..3c2803c34409707cf7870f91792be1d25745afba 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -45,15 +45,13 @@ ldns_rr_new_frm_type(ldns_rr_type t)
        
        desc = ldns_rr_descript(t);
 
-       rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, 
-                       ldns_rr_descriptor_minimum(desc));
+       rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, ldns_rr_descriptor_minimum(desc));
        for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
                rr->_rdata_fields[i] = NULL;
        }
        
        /* set the count to minimum */
-       ldns_rr_set_rd_count(rr, 
-                       ldns_rr_descriptor_minimum(desc));
+       ldns_rr_set_rd_count(rr, ldns_rr_descriptor_minimum(desc));
        ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
        ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
        ldns_rr_set_type(rr, t);
@@ -90,7 +88,8 @@ ldns_rr_free(ldns_rr *rr)
  * miek.nl. IN MX 10 elektron.atoom.net
  */
 ldns_rr *
-ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldns_rdf **prev)
+ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, 
+               ldns_rdf **prev)
 {
        ldns_rr *new;
        const ldns_rr_descriptor *desc;
@@ -133,8 +132,7 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldn
        rd_buf = LDNS_MALLOC(ldns_buffer);
        rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
        b64 = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
-       if (!new || !owner || !ttl || !clas || !rdata ||
-                       !rr_buf || !rd_buf || !rd | !b64) {
+       if (!new || !owner || !ttl || !clas || !rdata || !rr_buf || !rd_buf || !rd | !b64) {
                return NULL;
        }
        r_cnt = 0;
@@ -244,8 +242,7 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldn
                */
        }
 
-       ldns_buffer_new_frm_data(
-                       rd_buf, rdata, strlen(rdata));
+       ldns_buffer_new_frm_data( rd_buf, rdata, strlen(rdata));
 
        if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) {
                if (origin) {
@@ -268,7 +265,8 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldn
                } else {
                        ldns_rr_set_owner(new, ldns_dname_new_frm_str(owner));
                        if (!ldns_dname_str_absolute(owner) && origin) {
-                               if(ldns_dname_cat(ldns_rr_owner(new), origin) != LDNS_STATUS_OK) {
+                               if(ldns_dname_cat(ldns_rr_owner(new), 
+                                                       origin) != LDNS_STATUS_OK) {
                                        LDNS_FREE(owner); 
                                        LDNS_FREE(ttl); 
                                        LDNS_FREE(clas); 
@@ -310,20 +308,26 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldn
                default:
                        done = false;
 
-                       for (r_cnt = 0; !done && r_cnt < ldns_rr_descriptor_maximum(desc); r_cnt++) {
+                       for (r_cnt = 0; !done && r_cnt < ldns_rr_descriptor_maximum(desc); 
+                                       r_cnt++) {
                                quoted = false;
                                /* if type = B64, the field may contain spaces */
-                               if (ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_B64 ||
-                                   ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_LOC ||
-                                   ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_WKS ||
-                                   ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_NSEC ||
-                                   ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_STR
-                                   ) {
+                               if (ldns_rr_descriptor_field_type(desc, 
+                                                       r_cnt) == LDNS_RDF_TYPE_B64 ||
+                                   ldns_rr_descriptor_field_type(desc, 
+                                           r_cnt) == LDNS_RDF_TYPE_LOC ||
+                                   ldns_rr_descriptor_field_type(desc, 
+                                           r_cnt) == LDNS_RDF_TYPE_WKS ||
+                                   ldns_rr_descriptor_field_type(desc, 
+                                           r_cnt) == LDNS_RDF_TYPE_NSEC ||
+                                   ldns_rr_descriptor_field_type(desc, 
+                                           r_cnt) == LDNS_RDF_TYPE_STR) {
                                        delimiters = "\n\t";
                                } else {
                                        delimiters = "\n\t ";
                                }
-                               if (ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_STR) {
+                               if (ldns_rr_descriptor_field_type(desc, 
+                                                       r_cnt) == LDNS_RDF_TYPE_STR) {
                                        if (*(ldns_buffer_current(rd_buf)) == '\"') {
                                                delimiters = "\"\0";
                                                ldns_buffer_skip(rd_buf, 1);
@@ -332,7 +336,8 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin, ldn
                                }
                                /* because number of fields can be variable, we can't
                                   rely on _maximum() only */
-                               if ((c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN)) != -1) {
+                               if ((c = ldns_bget_token(rd_buf, rd, delimiters, 
+                                                               LDNS_MAX_RDFLEN)) != -1) {
                                        /* hmmz, rfc3597 specifies that any type can be represented with
                                         * \# method, which can contain spaces...
                                         * it does specify size though... 
@@ -1781,8 +1786,7 @@ ldns_get_rr_type_by_name(const char *name)
                desc_name = desc->_name;
                if(desc_name &&
                   strlen(name) == strlen(desc_name) &&
-                  strncasecmp(name, desc_name, strlen(desc_name)) == 0
-               ) {
+                  strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
                        return i;
                }
        }

diff --git a/test/codingstyle.tpkg b/test/codingstyle.tpkg
index 83af0f74126cb00855d7470f40cddafd0de35ea8..83734c2ade3fa16d251d90d3ea56c90eed9e9d8e 100644 (file)
--- a/test/codingstyle.tpkg
+++ b/test/codingstyle.tpkg
@@ -3,7 +3,7 @@
 # To extract the files from this archive, save it to some FILE, remove
 # everything before the `!/bin/sh' line above, then type `sh FILE'.
 #
-# Made on 2006-03-14 15:49 CET by <miekg@floep>.
+# Made on 2006-03-15 10:00 CET by <miekg@elektron>.
 # Source directory was `/home/miekg/svn/libdns/trunk/test/codingstyle.dir'.
 #
 # Existing files will *not* be overwritten unless `-c' is specified.
@@ -13,7 +13,7 @@
 # ------ ---------- ------------------------------------------
 #    270 -rw------- codingstyle.dsc
 #     36 -rw------- codingstyle.help
-#    874 -rw------- codingstyle.test
+#   1047 -rw------- codingstyle.test
 #
 save_IFS="${IFS}"
 IFS="${IFS}:"
@@ -63,7 +63,7 @@ else
 fi
 rm -f 200112312359.59 123123592001.59 123123592001.5 1231235901 $$.touch
 #
-if mkdir _sh20348; then
+if mkdir _sh06321; then
   $echo 'x -' 'creating lock directory'
 else
   $echo 'failed to create lock directory'
@@ -149,6 +149,14 @@ OPT="-ncs -sai -nut -ce -nfca -nlp -ncdb -br -ts08 -i8"
 X
 st=0
 for i in ../../*.c; do
+X
+X        case $i in
+X        "../../util.c" | "../../host2str.c")
+X                continue;;
+X        "../../error.c" | "../../rr.c")
+X                continue;;
+X        esac
+X
 X        case $OSTYPE in
 X        linux-gnu*)
 X                diff -w -u $i <(cat $i | indent -l$L $OPT) 
@@ -168,20 +176,20 @@ X        exit 1
 fi
 Xexit 0
 SHAR_EOF
-  (set 20 06 03 14 15 35 03 'codingstyle.test'; eval "$shar_touch") &&
+  (set 20 06 03 15 10 00 00 'codingstyle.test'; eval "$shar_touch") &&
   chmod 0600 'codingstyle.test' ||
   $echo 'restore of' 'codingstyle.test' 'failed'
   if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
   && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
     md5sum -c << SHAR_EOF >/dev/null 2>&1 \
     || $echo 'codingstyle.test:' 'MD5 check failed'
-8115e5ff989055074876d887e07a30fa  codingstyle.test
+e0be0c5e8fe0bde45d4deb10983aadb7  codingstyle.test
 SHAR_EOF
   else
     shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'codingstyle.test'`"
-    test 874 -eq "$shar_count" ||
-    $echo 'codingstyle.test:' 'original size' '874,' 'current size' "$shar_count!"
+    test 1047 -eq "$shar_count" ||
+    $echo 'codingstyle.test:' 'original size' '1047,' 'current size' "$shar_count!"
   fi
 fi
-rm -fr _sh20348
+rm -fr _sh06321
 exit 0

diff --git a/tsig.c b/tsig.c
index 6572496018943853e286750e3d1fe641df77d278..4ed02b681e12dd726df223d935bb20d31bab6bb2 100644 (file)
--- a/tsig.c
+++ b/tsig.c
@@ -105,7 +105,8 @@ ldns_tsig_prepare_pkt_wire(uint8_t *wire, size_t wire_len, size_t *result_len)
        }
        
        for (i = 0; i < ar_count; i++) {
-               status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_ADDITIONAL);
+               status = ldns_wire2rr(&rr, wire, wire_len, &pos, 
+                               LDNS_SECTION_ADDITIONAL);
                if (status != LDNS_STATUS_OK) {
                        return NULL;
                }
@@ -139,9 +140,11 @@ ldns_digest_function(char *name)
 #endif
 
 #ifdef HAVE_SSL
-static ldns_status ldns_tsig_mac_new(ldns_rdf **tsig_mac, uint8_t *pkt_wire, size_t pkt_wire_size,
-       const char *key_data, ldns_rdf *key_name_rdf, ldns_rdf *fudge_rdf, ldns_rdf *algorithm_rdf,
-       ldns_rdf *time_signed_rdf, ldns_rdf *error_rdf, ldns_rdf *other_data_rdf, ldns_rdf *orig_mac_rdf)
+static ldns_status 
+ldns_tsig_mac_new(ldns_rdf **tsig_mac, uint8_t *pkt_wire, size_t pkt_wire_size,
+               const char *key_data, ldns_rdf *key_name_rdf, ldns_rdf *fudge_rdf, 
+               ldns_rdf *algorithm_rdf, ldns_rdf *time_signed_rdf, ldns_rdf *error_rdf, 
+               ldns_rdf *other_data_rdf, ldns_rdf *orig_mac_rdf)
 {
        char *wireformat;
        int wiresize;
@@ -219,8 +222,9 @@ static ldns_status ldns_tsig_mac_new(ldns_rdf **tsig_mac, uint8_t *pkt_wire, siz
 
 #ifdef HAVE_SSL
 bool
-ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char *key_name, 
-               const char *key_data, ldns_rdf *orig_mac_rdf){
+ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, 
+               const char *key_name, const char *key_data, ldns_rdf *orig_mac_rdf)
+{
        ldns_rdf *fudge_rdf;
        ldns_rdf *algorithm_rdf;
        ldns_rdf *time_signed_rdf;
@@ -259,18 +263,9 @@ ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char *k
 
        prepared_wire = ldns_tsig_prepare_pkt_wire(wire, wirelen, &prepared_wire_size);
        
-       status = ldns_tsig_mac_new(&my_mac_rdf,
-                                     prepared_wire,
-                                     prepared_wire_size,
-                                     key_data, 
-                                     key_name_rdf,
-                                     fudge_rdf,
-                                     algorithm_rdf,
-                                     time_signed_rdf,
-                                     error_rdf,
-                                     other_data_rdf,
-                                     orig_mac_rdf
-                                    );
+       status = ldns_tsig_mac_new(&my_mac_rdf, prepared_wire, prepared_wire_size,
+                       key_data, key_name_rdf, fudge_rdf, algorithm_rdf, 
+                       time_signed_rdf, error_rdf, other_data_rdf, orig_mac_rdf);
        
        LDNS_FREE(prepared_wire);
        
@@ -297,8 +292,8 @@ ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char *k
 #ifdef HAVE_SSL
 /* TODO: memory :p */
 ldns_status
-ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, 
-               const char *algorithm_name, ldns_rdf *query_mac)
+ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, 
+               uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac)
 {
        ldns_rr *tsig_rr;
        ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name);
@@ -324,7 +319,8 @@ ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, ui
        /* bleh :p */
        if (gettimeofday(&tv_time_signed, NULL) == 0) {
                time_signed = LDNS_XMALLOC(uint8_t, 6);
-               ldns_write_uint64_as_uint48(time_signed, (uint64_t)tv_time_signed.tv_sec);
+               ldns_write_uint64_as_uint48(time_signed, 
+                               (uint64_t)tv_time_signed.tv_sec);
        } else {
                status = LDNS_STATUS_INTERNAL_ERR;
                goto clean;
@@ -345,18 +341,9 @@ ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, ui
                goto clean;
        }
 
-       status = ldns_tsig_mac_new(&mac_rdf,
-                                     pkt_wire,
-                                     pkt_wire_len,
-                                     key_data,
-                                     key_name_rdf, 
-                                     fudge_rdf, 
-                                     algorithm_rdf,
-                                     time_signed_rdf,
-                                     error_rdf,
-                                     other_data_rdf,
-                                     query_mac
-                                     );
+       status = ldns_tsig_mac_new(&mac_rdf, pkt_wire, pkt_wire_len,
+                       key_data, key_name_rdf, fudge_rdf, algorithm_rdf,
+                       time_signed_rdf, error_rdf, other_data_rdf, query_mac);
        
        if (!mac_rdf) {
                goto clean;