// -*- mode: C++; tab-width: 8; -*- // vi:ts=8 sw=4 noexpandtab autoindent /** * netportparser.cc * * Copyright 2011 Perforce Software. All rights reserved. * * This file is part of Perforce - the FAST SCM System. * * Description: * Parse a P4PORT into pieces. * pseudo-regex syntax loose definition: * * p4port ::= [prefix:][host:]port ; * prefix ::= "rsh"|"tcp"|"tcp4"|"tcp6"|"ssl"|"ssl4"|"ssl6" ; * NB: "tcp" means non-ssl, IPv4 only * "tcp4" means non-ssl, IPv4 only (synonym for "tcp") * "tcp6" means non-ssl, IPv6 only * "tcp46" means non-ssl, IPv4 or IPv6 (IPv4 preferred) * "tcp64" means non-ssl, IPv4 or IPv6 (IPv6 preferred) * "ssl" means ssl, IPv4 or IPv6 (IPv4 preferred) * "ssl4" means ssl, IPv4 only (synonym for "ssl") * "ssl6" means ssl, IPv6 only * "ssl46" means ssl, IPv4 or IPv6 (IPv4 preferred) * "ssl64" means ssl, IPv4 or IPv6 (IPv6 preferred) * NB: host may optionally be enclosed in square brackets: [...] * host := hostname |ipv4dottedquad | ipv6hex | ipv6mappedv4 ; * hostname := label[. label]* ; * label := [A-Za-z0-9-_]+ ; // LDH; by convention (but all octets are allowed) * ipv4dottedquad := decoctet.decoctet.decoctet.decoctet ; * digit := [0-9] ; * decoctet := digit{1,3} ; * hexchar := [0-9A-Fa-f] ; * hexword := hexchar{1,4} ; * NB: leading 0s may (but need not) be omitted * ipv6hex := hexword:hexword:hexword:hexword:hexword:hexword ; * NB: 64-bit network prefix and 64-bit interface id [eg, host address] * (unless high 3 bits are 0) * Exactly one pair of adjacent colons indicates enough 0 hexwords to fill to 8 hexwords total * * unspecified ::0 (IN6ADDR_ANY) * loopback ::1 (IN6ADDR_LOOPBACK) * link-local FE80::* (FE80::/10, 54 bits 0, 64-bits interface id) * site-local FEC0::* (FEC0::/10, 54 bits subnet id, 64-bits interface id) [deprecated] * anycast interface id of 0 * * See RFC 4291 "IP Version 6 Addressing Architecture" * See RFC 5952 "A Recommendation for IPv6 Address Text Representation" * ipv6mappedv4 := hexword:hexword:hexword:hexword:ipv4dottedquad * | hexword:hexword:hexword:hexword:hexword:hexword ; * NB: Upper 80 bits are 0, then 16 bits of 1, then 32-bit IPv4 address in dotted-quad or hex * So normally written as ::FFFF:127.0.0.1 * See RFC 6052 "IPv6 Addressing of IPv4/IPv6 Translators" * * (1) If the text from the beginning of the string to the first colon * matches one of our known prefixes, remember it as the prefix * and skip past the colon. * (2) The host portion may be enclosed in square brackets; if so, the port * is the part after the right bracket (it may/should be preceded by a colon). * See "RFC 3986 : Uniform Resource Identifier (URI): Generic Syntax", * "Section 3.2.2. Host". * (3) Otherwise the text after the last colon (or the entire string if no colon) * is the port. It is allowed to be empty (for bind() OS chooses port). * (4) Anything left is the host (name or address [IPv4 or IPv6]). * * (a) IPv4: ":0" means "localhost:0" for connect, and "*:0" for bind * (b) IPv4: "" and ":" mean ":0" * (c) IPv6: ":::nnnn" means host="::", port="nnnn" * (d) IPv6: ":::0" means "localhost::0" for connect, and "*::0" for bind * * We don't parse the host field! But we do grovel through it a bit ... * * Hostname syntax: * * see RFC 952 "DOD INTERNET HOST TABLE SPECIFICATION" * - DNS labels are LDH (Letters, Digits, and Hyphen), and start with a letter. * * see RFC 1123 "Requirements for Internet Hosts -- Application and Support" * - now DNS labels may also start with a digit. * * see RFC 2181 "Clarifications to the DNS Specification" * - DNS label octets may contain any binary value (but we don't support this). * * IDNA (non-ASCII DNS names [eg, Unicode]) * - we do NOT support IDNA at this time. * - see RFC 3492 "Punycode: A Bootstring encoding of Unicode * for Internationalized Domain Names in Applications (IDNA)" * - see RFC 5890 "Internationalized Domain Names for Applications (IDNA): * Definitions and Document Framework" * - see RFC 5891 "Internationalized Domain Names in Applications (IDNA): Protocol" */ # include # include # include # include # include # include "netport.h" # include "netportipv6.h" # include "netportparser.h" # include "netutils.h" # include "debug.h" # include "tunable.h" /* * In 2012.1 and 2012.2, IPv6 infrastructure is in place but is neither documented * nor supported. Customers will use only IPv4; IPv6 is reserved for internal use * and testing. Therefore we force all P4PORT strings to use IPv4 unless they * explicitly specify IPv6. Transport prefixes of "tcp:" or "ssl:" (or none) * therefore are equivalent to "tcp4:" and "ssl4:" * * In 2013.1 IPv6 will be fully documented and supported, and we will continue * to support IPv4. Users will be able to force IPv4, force IPv6, prefer IPv4, * or prefer IPv6. At that time, the meaning of no prefix, "tcp:", and "ssl:" * will change: always forcing IPv4 will be optional during address resolution. * * If the user requests compliance with RFC 3484 via the "net.rfc3484" tunable, * then the prefixes "tcp:" and "ssl:" will mean that we let the OS choose between * IPv4 and IPv6 in conformance to RFC 3484, which specifies the precedence in * which addresses should be resolved. * If they don't set "net.rfc3484" (or set it to 0) then they will continue to * prefer IPv4, as in earlier releases. * * See RFC 3484 "Default Address Selection for Internet Protocol version 6 (IPv6)". * Note that it is optional for host administrators to be able to modify this * precedence table: * - linux/Unix: edit /etc/gai.conf * - Windows: netsh.exe interface ipv6 * - Mac OS X: appears to modify precedence dynamically based on * routing timing to favor working addresses. * * Uncomment the definition of RFC_3484_COMPLIANT to enable the 2013.1 behavior * (and do the same in to pass the unit tests). * In 2013.1 we can remove this macro and the ifdef's, but for now this allows * us easily to test both current and new behavior. */ # define RFC_3484_COMPLIANT /* * If we allow RFC 3484 compliance, return true iff the user has enabled it * (via the "net.rfc3484" tunable). Otherwise return false. */ static bool HonorRFC3484() { # ifdef RFC_3484_COMPLIANT return p4tunable.Get( P4TUNE_NET_RFC3484 ); # else return false; # endif // RFC_3484_COMPLIANT } /* * Orthodox Canonical Form (OCF) methods */ /** * default ctor */ NetPortParser::NetPortParser() : mPortString("") , mTransport("") , mHost("") , mPort("") , mHostPort("") , mPortColon(false) { mPrefix.mType = PT_NONE; mPrefix.mName = ""; } // default ctor NetPortParser::NetPortParser( const StrRef &portstr) : mPortString(portstr) , mTransport("") , mHost("") , mPort("") , mHostPort("") , mPortColon(false) { mPrefix.mType = PT_NONE; mPrefix.mName = ""; Parse(); } NetPortParser::NetPortParser( const char *portstr) : mPortString(portstr) , mTransport("") , mHost("") , mPort("") , mHostPort("") , mPortColon(false) { mPrefix.mType = PT_NONE; mPrefix.mName = ""; Parse(); } /** * copy ctor */ NetPortParser::NetPortParser( const NetPortParser &rhs) : mPortString(rhs.mPortString) , mTransport(rhs.mTransport) , mHost(rhs.mHost) , mPort(rhs.mPort) , mHostPort(rhs.mHostPort) , mPrefix(rhs.mPrefix) , mPortColon(rhs.mPortColon) { } // copy ctor /** * dtor */ NetPortParser::~NetPortParser() { } // dtor /** * assignment op */ const NetPortParser & NetPortParser::operator=( const NetPortParser &rhs) { if( this != &rhs ) { mPortString = rhs.mPortString; mTransport = rhs.mTransport; mHost = rhs.mHost; mPort = rhs.mPort; mHostPort = rhs.mHostPort; mPortColon = rhs.mPortColon; mPrefix = rhs.mPrefix; } return *this; } // op= /** * op== */ bool NetPortParser::operator==( const NetPortParser &rhs) const { if( this == &rhs ) { return true; } if( mPortString != rhs.mPortString ) return false; if( mTransport != rhs.mTransport ) return false; if( mHost != rhs.mHost ) return false; if( mPort != rhs.mPort ) return false; if( mHostPort != rhs.mHostPort ) return false; if( mPortColon != rhs.mPortColon ) return false; if( mPrefix.mType != rhs.mPrefix.mType ) return false; return true; } // op== /** * op!= */ bool NetPortParser::operator!=( const NetPortParser &rhs) const { return !(*this == rhs); } // op!= // accessors /* * RFC 3484 specifies a precedence for deciding the order of returned * addresses to be used for connect/bind. If we're following RFC 3484 * we use the list returned by getaddrinfo() as-is. Otherwise we'll * filter out rejected families (via MustIPv4() and MustIPv6()) and then * try the preferred family (if any) first. This filtering and ordering * is applied to the already-ordered list returned by getaddrinfo(). * * In 2012.1, NetPortParser.MustRfc3484() will always return false, * but in 2013.1 and later it will return the value of "-v net.rfc3484" * if the transport didn't specify an IPv4 or IPv6 preference; eg, * no transport prefix, or a prefix of "tcp:" or "ssl:" (and the host * wasn't a numeric address). * * If this causes problems for customers then we might want * to continue to return false until a later date. * * See RFC 3484 "Default Address Selection for Internet Protocol version 6 (IPv6)". */ bool NetPortParser::MustRfc3484() const { switch( mPrefix.mType ) { case PT_NONE: case PT_TCP: case PT_SSL: return HonorRFC3484(); default: return false; } } bool NetPortParser::MayIPv4() const { switch( mPrefix.mType ) { case PT_NONE: case PT_TCP: case PT_TCP4: case PT_TCP46: case PT_TCP64: case PT_SSL: case PT_SSL4: case PT_SSL46: case PT_SSL64: return true; default: return false; } } bool NetPortParser::MayIPv6() const { switch( mPrefix.mType ) { case PT_TCP6: case PT_TCP46: case PT_TCP64: case PT_SSL6: case PT_SSL46: case PT_SSL64: return true; case PT_NONE: case PT_TCP: case PT_SSL: return HonorRFC3484(); default: return false; } } bool NetPortParser::PreferIPv4() const { switch( mPrefix.mType ) { case PT_NONE: case PT_TCP: case PT_SSL: return !HonorRFC3484(); case PT_TCP4: case PT_TCP46: case PT_SSL4: case PT_SSL46: return true; default: return false; } } bool NetPortParser::PreferIPv6() const { switch( mPrefix.mType ) { case PT_TCP6: case PT_TCP64: case PT_SSL6: case PT_SSL64: return true; default: return false; } } // explicitly listed IPv6? bool NetPortParser::WantIPv6() const { switch( mPrefix.mType ) { case PT_TCP6: case PT_TCP46: case PT_TCP64: case PT_SSL6: case PT_SSL46: case PT_SSL64: return true; default: return false; } } bool NetPortParser::MayRSH() const { // RSH is never optional; either you must use RSH or you must not return MustRSH(); } bool NetPortParser::MustRSH() const { return mPrefix.mType == PT_RSH; } bool NetPortParser::MustSSL() const { switch( mPrefix.mType ) { case PT_SSL: case PT_SSL4: case PT_SSL6: case PT_SSL46: case PT_SSL64: return true; default: return false; } } bool NetPortParser::MustIPv4() const { switch( mPrefix.mType ) { case PT_NONE: case PT_TCP: case PT_SSL: return !HonorRFC3484(); case PT_TCP4: case PT_SSL4: return true; default: return false; } } bool NetPortParser::MustIPv6() const { return mPrefix.mType == PT_TCP6 || mPrefix.mType == PT_SSL6; } const StrBuf NetPortParser::String( PPOpts opts) const { StrBuf result; StrBuf tmp; if( opts & PPO_TRANSPORT ) { tmp = Transport(); if( tmp.Length() && (tmp != "tcp") ) // don't report the default transport { result.Set( tmp ); result.Append( ":" ); } } tmp = Host(); if( tmp.Length() ) { result.Append( &tmp ); } if( opts & PPO_PORT ) { result.Append( ":" ); tmp = Port(); result.Append( &tmp ); } return result; } int NetPortParser::PortNum() const { return Port().Atoi(); } /* * Other methods */ const NetPortParser::Prefix * NetPortParser::FindPrefix( const char *prefix, int len) { static const Prefix prefixes[] = { {"rsh", PT_RSH}, {"tcp", PT_TCP}, {"tcp4", PT_TCP4}, {"tcp6", PT_TCP6}, {"tcp46", PT_TCP46}, {"tcp64", PT_TCP64}, {"ssl", PT_SSL}, {"ssl4", PT_SSL4}, {"ssl6", PT_SSL6}, {"ssl46", PT_SSL46}, {"ssl64", PT_SSL64}, {"", PT_NONE} }; static const int kNoPrefix = 11; // index of the PT_NONE entry if( (len < 3) || (len > 5) ) { // all of our prefixes are 3, 4, or 5 chars long return &prefixes[kNoPrefix]; } const Prefix *pfx; for( pfx = prefixes; pfx->mName[0]; ++pfx ) { if( strncmp(prefix, pfx->mName, len) == 0 ) return pfx; } return pfx; } void NetPortParser::Parse() { const Prefix *pfx = FindPrefix( "", 0 ); // init to PT_NONE const char *str = mPortString.Text(); // find the prefix const char *p = strchr(str, ':'); if( p ) { pfx = FindPrefix( str, p-str ); if( pfx->mType != PT_NONE ) { // skip past valid prefix str = ++p; } // don't parse rsh: cmd // store the cmd in the host field if( pfx->mType == PT_RSH ) { mPrefix = *pfx; mHost.Set( str ); mHostPort.Set( str ); mTransport = mPrefix.mName; return; } } else if( strcmp(str, "rsh") == 0 ) { pfx = FindPrefix( "rsh", 3 ); mPrefix = *pfx; mHost.Set( str ); mHostPort.Set( str ); mTransport = mPrefix.mName; return; } // address is optionally enclosed in square brackets const char *rbracket = NULL; if( *str == '[' ) { rbracket = strrchr(str, ']'); if( rbracket ) ++str; // skip past the lbracket } // count the colons after the prefix (if any) int numColons = 0; const char *lastColon = NULL; for( const char *cp = str; *cp; cp++ ) { if( *cp == ':' ) { lastColon = cp; numColons++; } } if( rbracket ) { mHost.Set( str, rbracket - str ); --str; // backup to include the left bracket mHostPort.Set( str ); // If there are matched brackets, the host is everything inside the brackets // and the port is everything after the right bracket (skipping the // following colon). if( rbracket[1] == ':' ) { rbracket++; numColons--; // don't count the port-marking colon mPortColon = true; } mPort.Set( rbracket+1 ); // may be empty } else if( lastColon ) { // if there is a colon, the port is everything after the last colon // and host is everything before it (after the optional prefix) mPort.Set( lastColon+1 ); // may be empty mHost.Set( str, lastColon - str ); mHostPort.Set( str ); numColons--; // don't count the port-marking colon mPortColon = true; } else { // if no colon, the entire string is the port mPort.Set( str ); mHostPort.Set( str ); } // remember the prefix mPrefix = *pfx; // If neither IPv4 nor IPv6 was specified but a numeric address was given, // determine the transport type from the address. bool ssl = false; switch( pfx->mType ) { case PT_SSL: ssl = true; // Fall through! case PT_NONE: case PT_TCP: /* * If there are 2 or more colons and it's a numeric IPv6 address, * default to "tcp6"; (IPv6 numeric addresses must have at least * 2 colons, and we don't accept colons in a hostname, so 2 or more * means numeric IPv6 address). * * If 0 or 1 colons, default to "tcp4" if the host * is an IPv4 numeric address. */ if( numColons >= 2 ) { if( NetUtils::IsIpV6Address(mHost.Text()) ) mPrefix = *FindPrefix( ssl ? "ssl6" : "tcp6", 4 ); } else { if( NetUtils::IsIpV4Address(mHost.Text(), NetUtils::IPADDR_PREFIX_PROHIBIT) ) mPrefix = *FindPrefix( ssl ? "ssl4" : "tcp4", 4 ); } break; } mTransport = mPrefix.mName; } // JIRA P4-10855, job065290 bool NetPortParser::IsValid(Error *e) const { if( !MustRSH() && !mPortColon && (mPort.Length() <= 0) ) { e->Set( MsgServer::PortMissing ) << String(); return false; } return true; } void NetPortParser::Parse(const StrRef &portstr) { mPortString = portstr; Parse(); }