Return to inet.C CVS log

Up to [parser3project] / parser3 / src / classes

Annotation of parser3/src/classes/inet.C, revision 1.2

1.1       misha       1: /** @file
                      2:        Parser: @b inet parser class.
                      3: 
                      4:        Copyright(c) 2001-2005 ArtLebedev Group(http://www.artlebedev.com)
                      5:        Author: Alexandr Petrosian <paf@design.ru>(http://paf.design.ru)
                      6: */
                      7: 
1.2     ! misha       8: static const char * const IDENT_INET_C="$Date: 2008-06-16 12:37:59 $";
1.1       misha       9: 
                     10: #include "pa_vmethod_frame.h"
                     11: #include "pa_request.h"
                     12: 
                     13: class MInet: public Methoded {
                     14: public:
                     15:        MInet();
                     16: 
                     17: public: // Methoded
                     18:        bool used_directly() { return true; }
                     19: };
                     20: 
                     21: // global variables
                     22: 
                     23: DECLARE_CLASS_VAR(inet, new MInet, 0);
                     24: 
                     25: 
                     26: static void _ntoa(Request& r, MethodParams& params){
                     27:        unsigned long l=(unsigned long)trunc(params.as_double(0, "parameter must be expression", r));
1.2     ! misha      28:        static const int ip_cstr_bufsize=3*4+3+1+1;
1.1       misha      29:        char* ip_cstr=new(PointerFreeGC) char[ip_cstr_bufsize];
                     30: 
                     31:        snprintf(ip_cstr, ip_cstr_bufsize, "%u.%u.%u.%u",
                     32:                                (l>>24) & 0xFF,
                     33:                                (l>>16) & 0xFF,
                     34:                                (l>>8) & 0xFF,
                     35:                                l & 0xFF);
                     36: 
                     37:        r.write_no_lang(*new String(ip_cstr));
                     38: }
                     39: 
                     40: static void _aton(Request& r, MethodParams& params){
                     41:        const String ip=params.as_string(0, PARAMETER_MUST_BE_STRING);
                     42:        if(ip.is_empty())
                     43:                throw Exception(PARSER_RUNTIME,
                     44:                        0,
                     45:                        "IP address must not be empty.");
                     46: 
                     47:        const char* ip_cstr=ip.cstr();
                     48:        ulong result=0;
                     49:        uint byte_value=0;
                     50:        uint dot_cnt=0;
                     51:        bool byte_start=true;
                     52:        bool err=false;
                     53:        const char* p=ip_cstr;
                     54:        while(char c=*p++){
                     55:                uint digit=(uint)(c-'0');       // assume ascii
                     56:                if(digit>=0 && digit<=9){
                     57:                        byte_start=false;
                     58:                        if((byte_value=byte_value*10+digit) > 255){
                     59:                                err=true;
                     60:                                break;
                     61:                        }
                     62:                } else if(c=='.'){
                     63:                        if(byte_start){ // two dots in row or IP started with dot
                     64:                                err=true;
                     65:                                break;
                     66:                        } else {
                     67:                                byte_start=true;
                     68:                                dot_cnt++;
                     69:                                result=(result << 8)+(ulong)byte_value;
                     70:                                byte_value=0;
                     71:                        }
                     72:                } else { // invalid char
                     73:                        err=true;
                     74:                        break;
                     75:                }
                     76:        }
                     77: 
                     78:        if(err || dot_cnt!=3 || byte_start){
                     79:                throw Exception(PARSER_RUNTIME,
                     80:                        0,
                     81:                        "Invalid IP address '%s' specified.", ip_cstr);
                     82:        } else {
                     83:                result=(result << 8)+(ulong)byte_value;
                     84:                r.write_no_lang(*new VDouble(result));
                     85:        }
                     86: }
                     87: 
                     88: // constructor
                     89: MInet::MInet(): Methoded("inet") {
                     90:        add_native_method("ntoa", Method::CT_STATIC, _ntoa, 1, 1);
                     91:        add_native_method("aton", Method::CT_STATIC, _aton, 1, 1);
                     92: 
                     93:        // todo: gethostbyname, gethostbyaddr
                     94: }