more types

diff --git a/parse.c b/parse.c
index d2dc57d5490fb2a36f16733e19181d5ae56b987c..71b274df31352ea045260e59e8b42e3cba41718c 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -125,7 +125,7 @@ ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
                        continue;
                }
 
-               if (c == '\n' && p != 0) {
+               if (c == '\n' && p != 0 && t > token) {
                        /* in parentheses */
                        continue;
                }
@@ -144,6 +144,7 @@ ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
                        return -1;
                }
        }
+
        *t = '\0';
        if (i == 0) {
                /* nothing read */
@@ -160,6 +161,7 @@ tokenread:
        if (p != 0) {
                return -1;
        }
+
        return (ssize_t)i;
 }
 

diff --git a/rr.c b/rr.c
index 89bcd6c64cfe38ebf32fd2ce746a03e83e9c3ed7..8b5ceb7b2c86d177ebe635605eda99f0aa7998ee 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -292,7 +292,7 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin)
         * the rdata differently, e.g. NSEC */
        switch(rr_type) {
                case LDNS_RR_TYPE_NSEC:
-               case LDNS_RR_TYPE_LOC:
+               /*case LDNS_RR_TYPE_LOC:*/
                        /* blalba do something different */
                        break;
                default:
@@ -306,9 +306,12 @@ ldns_rr_new_frm_str(const char *str, uint16_t default_ttl, ldns_rdf *origin)
                        }
                        */
                        done = false;
+
                        for (r_cnt = 0; !done && r_cnt < ldns_rr_descriptor_maximum(desc); r_cnt++) {
                                /* if type = B64, the field may contain spaces */
-                               if (ldns_rr_descriptor_field_type(desc, r_cnt) == LDNS_RDF_TYPE_B64) {
+                               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
+                                   ) {
                                        delimiters = "\n\t";
                                } else {
                                        delimiters = "\n\t ";

diff --git a/str2host.c b/str2host.c
index e07fa6293e07d0f67515f19b41d72ccf95333282..7c3a679827c9eea0cfb81af49ab49441c5503c9f 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -494,6 +494,8 @@ ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
 ldns_status
 ldns_str2rdf_unknown(ldns_rdf **rd, const char *str)
 {
+       /* this should be caught in an earlier time (general str2host for 
+          rr's */
        rd = rd;
        str = str;
        return LDNS_STATUS_NOT_IMPL;
@@ -502,6 +504,7 @@ ldns_str2rdf_unknown(ldns_rdf **rd, const char *str)
 ldns_status
 ldns_str2rdf_tsig(ldns_rdf **rd, const char *str)
 {
+       /* there is no strign representation for TSIG rrs */
        rd = rd;
        str = str;
        return LDNS_STATUS_NOT_IMPL;
@@ -510,6 +513,7 @@ ldns_str2rdf_tsig(ldns_rdf **rd, const char *str)
 ldns_status
 ldns_str2rdf_service(ldns_rdf **rd, const char *str)
 {
+       /* is this used? is this actually WKS? or SRV? */
        rd = rd;
        str = str;
        return LDNS_STATUS_NOT_IMPL;
@@ -518,9 +522,227 @@ ldns_str2rdf_service(ldns_rdf **rd, const char *str)
 ldns_status
 ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
 {
-       rd = rd;
-       str = str;
-       return LDNS_STATUS_NOT_IMPL;
+       uint32_t size = 0;
+       uint32_t horiz_pre = 0;
+       uint32_t vert_pre = 0;
+       uint32_t latitude = 0;
+       uint32_t longitude = 0;
+       uint32_t altitude = 0;
+
+       uint8_t *data;
+       uint32_t equator = (uint32_t) ldns_power(2, 31);
+
+       uint32_t h = 0;
+       uint32_t m = 0;
+       uint8_t size_b = 1, size_e = 2;
+       uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
+       uint8_t vert_pre_b = 1, vert_pre_e = 3;
+       
+       double s = 0.0;
+       bool northerness;
+       bool easterness;
+
+       char *my_str = (char *) str;
+
+       /* only support version 0 */
+       if (isdigit(*my_str)) {
+               h = strtol(my_str, &my_str, 10);
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (isdigit(*my_str)) {
+               m = strtol(my_str, &my_str, 10);
+       } else if (*my_str == 'N' || *my_str == 'S') {
+               goto northerness;
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (isdigit(*my_str)) {
+               s = strtod(my_str, &my_str);
+       }
+
+       northerness:
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (*my_str == 'N') {
+               northerness = true;
+       } else if (*my_str == 'S') {
+               northerness = false;
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       my_str++;
+
+       /* store number */
+       latitude = 1000 * s;
+       latitude += 1000 * 60 * m;
+       latitude += 1000 * 60 * 60 * h;
+       if (northerness) {
+               latitude = equator + latitude;
+       } else {
+               latitude = equator - latitude;
+       }
+
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (isdigit(*my_str)) {
+               h = strtol(my_str, &my_str, 10);
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (isdigit(*my_str)) {
+               m = strtol(my_str, &my_str, 10);
+       } else if (*my_str == 'E' || *my_str == 'W') {
+               goto easterness;
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (isdigit(*my_str)) {
+               s = strtod(my_str, &my_str);
+       }
+
+       easterness:
+       while (isblank(*my_str)) {
+               my_str++;
+       }
+
+       if (*my_str == 'E') {
+               easterness = true;
+       } else if (*my_str == 'W') {
+               easterness = false;
+       } else {
+               return LDNS_STATUS_INVALID_STR;
+       }
+
+       my_str++;
+
+       /* store number */
+       longitude = 1000 * s;
+       longitude += 1000 * 60 * m;
+       longitude += 1000 * 60 * 60 * h;
+
+       if (easterness) {
+               longitude += equator;
+       } else {
+               longitude = equator - longitude;
+       }
+
+       altitude = strtol(my_str, &my_str, 10);
+       altitude *= 100;
+       altitude += 10000000;
+       if (*my_str == 'm' || *my_str == 'M') {
+               *my_str++;
+       }
+
+       if (strlen(my_str) > 0) {
+               while (isblank(*my_str)) {
+                       my_str++;
+               }
+               size = strtol(my_str, &my_str, 10);
+               /* convert to centimeters */
+               size = size * 100;
+               /* get values for weird rfc notation */
+               size_e = 0;
+               while (size >= 10) {
+                       size_e++;
+                       size = size / 10;
+               }
+               size_b = (uint8_t) size;
+               if (size_e > 9) {
+                       printf("size too large\n");
+                       return LDNS_STATUS_INVALID_STR;
+               }
+               if (*my_str == 'm' || *my_str == 'M') {
+                       *my_str++;
+               }
+       }
+
+       if (strlen(my_str) > 0) {
+               while (isblank(*my_str)) {
+                       my_str++;
+               }
+               horiz_pre = strtol(my_str, &my_str, 10);
+               /* convert to centimeters */
+               horiz_pre = horiz_pre * 100;
+               /* get values for weird rfc notation */
+               horiz_pre_e = 0;
+               while (horiz_pre >= 10) {
+                       horiz_pre_e++;
+                       horiz_pre = horiz_pre / 10;
+               }
+               horiz_pre_b = (uint8_t) horiz_pre;
+               if (horiz_pre_e > 9) {
+                       printf("horiz_pre too large\n");
+                       return LDNS_STATUS_INVALID_STR;
+               }
+               if (*my_str == 'm' || *my_str == 'M') {
+                       *my_str++;
+               }
+       }
+
+       if (strlen(my_str) > 0) {
+               while (isblank(*my_str)) {
+                       my_str++;
+               }
+               vert_pre = strtol(my_str, &my_str, 10);
+               /* convert to centimeters */
+               vert_pre = vert_pre * 100;
+               /* get values for weird rfc notation */
+               vert_pre_e = 0;
+               while (vert_pre >= 10) {
+                       vert_pre_e++;
+                       vert_pre = vert_pre / 10;
+               }
+               vert_pre_b = (uint8_t) vert_pre;
+               if (vert_pre_e > 9) {
+                       printf("vert_pre too large\n");
+                       return LDNS_STATUS_INVALID_STR;
+               }
+               if (*my_str == 'm' || *my_str == 'M') {
+                       *my_str++;
+               }
+       }
+
+       data = LDNS_XMALLOC(uint8_t, 16);
+       data[0] = 0;
+       data[1] = 0;
+       data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
+       data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
+       data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
+       ldns_write_uint32(data + 4, latitude);
+       ldns_write_uint32(data + 8, longitude);
+       ldns_write_uint32(data + 12, altitude);
+
+       *rd = ldns_rdf_new_frm_data(
+               LDNS_RDF_TYPE_LOC, 16, data);
+
+       LDNS_FREE(data);
+       return LDNS_STATUS_OK;
 }
 
 ldns_status

diff --git a/zone.c b/zone.c
index 356824756e3cdb7e0bc89f3ee4d20bcf92fd849b..64626b5408847d8ffd12c03f59ce06edd40b79d9 100644 (file)
--- a/zone.c
+++ b/zone.c
@@ -86,6 +86,7 @@ ldns_zone_new_frm_fp(FILE *fp, ldns_rdf *origin, uint16_t ttl, ldns_rr_class c)
        ldns_rdf *my_origin = origin;
        uint16_t my_ttl = ttl;
        ldns_rr_class my_class = c;
+       ldns_rr *last_rr = NULL;
 
        uint8_t i;
 
@@ -94,6 +95,7 @@ ldns_zone_new_frm_fp(FILE *fp, ldns_rdf *origin, uint16_t ttl, ldns_rr_class c)
        my_ttl    = ttl;
        my_class  = c;
        
+
        /* read until we got a soa, all crap above is discarded 
         * except $directives
         */
@@ -124,6 +126,7 @@ ldns_zone_new_frm_fp(FILE *fp, ldns_rdf *origin, uint16_t ttl, ldns_rr_class c)
        while(!feof(fp)) {
                rr = ldns_rr_new_frm_fp(fp, my_ttl, my_origin);
                if (rr) {
+                       last_rr = rr;
                        if (!ldns_zone_push_rr(newzone, rr)) {
                                printf("error pushing rr\n");
                                return NULL;
@@ -134,7 +137,9 @@ ldns_zone_new_frm_fp(FILE *fp, ldns_rdf *origin, uint16_t ttl, ldns_rr_class c)
                        my_class  = ldns_rr_get_class(rr);
                        
                } else {
-                       fprintf(stderr, "Error in file, unable to read RR\n");
+                       fprintf(stderr, "Error in file, unable to read RR.\nLast rr that was parsed:\n");
+                       ldns_rr_print(stdout, last_rr);
+                       printf("\n");
                }
        }
        return newzone;