Standardize error reporting of IPEndPoint::ToSockAddr and

net/socket/tcp_socket_libevent.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/tcp_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
@@ skipping 593 matching lines @@
     if (net_error != ERR_IO_PENDING)
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
     return net_error;
   }
 
   IPEndPoint ip_end_point;
   if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
     NOTREACHED();
     if (IGNORE_EINTR(close(new_socket)) < 0)
       PLOG(ERROR) << "close";
-    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT,
-                                      ERR_ADDRESS_INVALID);
-    return ERR_ADDRESS_INVALID;
+    int net_error = ERR_ADDRESS_INVALID;
+    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
+    return net_error;
   }
   scoped_ptr<TCPSocketLibevent> tcp_socket(new TCPSocketLibevent(
       net_log_.net_log(), net_log_.source()));
   int adopt_result = tcp_socket->AdoptConnectedSocket(new_socket, ip_end_point);
   if (adopt_result != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, adopt_result);
     return adopt_result;
   }
   *socket = tcp_socket.Pass();
   *address = ip_end_point;
   net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
                     CreateNetLogIPEndPointCallback(&ip_end_point));
   return OK;
 }
 
 int TCPSocketLibevent::DoConnect() {
   DCHECK_EQ(0, connect_os_error_);
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       CreateNetLogIPEndPointCallback(peer_address_.get()));
 
   // Connect the socket.
   if (!use_tcp_fastopen_) {
     SockaddrStorage storage;
     if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len))
-      return ERR_INVALID_ARGUMENT;
+      return ERR_ADDRESS_INVALID;
 
     if (!HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len))) {
       // Connected without waiting!
       return OK;
     }
   } else {
     // With TCP FastOpen, we pretend that the socket is connected.
     DCHECK(!tcp_fastopen_connected_);
     return OK;
   }
@@ skipping 165 matching lines @@
     accept_callback_.Reset();
     callback.Run(result);
   }
 }
 
 int TCPSocketLibevent::InternalWrite(IOBuffer* buf, int buf_len) {
   int nwrite;
   if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
     SockaddrStorage storage;
     if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len)) {
-      errno = EINVAL;

[wtc, 2014/03/04 00:43:28]

Setting errno to EINVAL here was apparently an attempt to get MapSystemError()
to return ERR_INVALID_ARGUMENT later (see line 642 above). So if we want
MapSystemError() to return ERR_ADDRESS_INVALID instead, we'll need to set errno
to EADDRNOTAVAIL.

[eroman, 2014/03/04 03:01:10]

That is kind of gross

+      errno = EADDRNOTAVAIL;
       return -1;
     }
 
     int flags = 0x20000000; // Magic flag to enable TCP_FASTOPEN.
 #if defined(OS_LINUX)
     // sendto() will fail with EPIPE when the system doesn't support TCP Fast
     // Open. Theoretically that shouldn't happen since the caller should check
     // for system support on startup, but users may dynamically disable TCP Fast
     // Open via sysctl.
     flags |= MSG_NOSIGNAL;
@@ skipping 56 matching lines @@
       }
     } else {
       fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ?
                            FAST_OPEN_SYN_DATA_FAILED :
                            FAST_OPEN_NO_SYN_DATA_FAILED);
     }
   }
 }
 
 }  // namespace net