Multicast socket API

chrome/common/extensions/permissions/socket_permission_data.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/permissions/socket_permission_data.h"
 
 #include <cstdlib>
 #include <sstream>
 #include <vector>
 
@@ skipping 12 matching lines @@
 using extensions::SocketPermissionData;
 
 const char kColon = ':';
 const char kDot = '.';
 const char kWildcard[] = "*";
 const char kInvalid[] = "invalid";
 const char kTCPConnect[] = "tcp-connect";
 const char kTCPListen[] = "tcp-listen";
 const char kUDPBind[] = "udp-bind";
 const char kUDPSendTo[] = "udp-send-to";
+const char kUDPMulticastMembership[] = "udp-multicast-membership";
 const int kWildcardPortNumber = 0;
 const int kInvalidPort = -1;
 
 SocketPermissionRequest::OperationType StringToType(const std::string& s) {
   if (s == kTCPConnect)
     return SocketPermissionRequest::TCP_CONNECT;
   if (s == kTCPListen)
     return SocketPermissionRequest::TCP_LISTEN;
   if (s == kUDPBind)
     return SocketPermissionRequest::UDP_BIND;
   if (s == kUDPSendTo)
     return SocketPermissionRequest::UDP_SEND_TO;
+  if (s == kUDPMulticastMembership)
+    return SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP;
   return SocketPermissionRequest::NONE;
 }
 
 const char* TypeToString(SocketPermissionRequest::OperationType type) {
   switch (type) {
     case SocketPermissionRequest::TCP_CONNECT:
       return kTCPConnect;
     case SocketPermissionRequest::TCP_LISTEN:
       return kTCPListen;
     case SocketPermissionRequest::UDP_BIND:
       return kUDPBind;
     case SocketPermissionRequest::UDP_SEND_TO:
       return kUDPSendTo;
+    case SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP:

[miket_OOO, 2013/04/25 21:52:12]

spelling (fix everywhere, please)

+      return kUDPMulticastMembership;
     default:
       return kInvalid;
   }
 }
 
 bool StartsOrEndsWithWhitespace(const std::string& str) {
   if (str.find_first_not_of(kWhitespaceASCII) != 0)
     return true;
   if (str.find_last_not_of(kWhitespaceASCII) != str.length() - 1)
     return true;
@@ skipping 132 matching lines @@
     if (tokens.empty() || tokens.size() > 3)
       break;
 
     pattern_.type = StringToType(tokens[0]);
     if (pattern_.type == SocketPermissionRequest::NONE)
       break;
 
     if (tokens.size() == 1)
       return true;
 
+    // Multicast membership permission string does not include an address.
+    if (pattern_.type == SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP)
+      return false;
+
     pattern_.host = tokens[1];
     if (!pattern_.host.empty()) {
       if (StartsOrEndsWithWhitespace(pattern_.host))
         break;
       pattern_.host = StringToLowerASCII(pattern_.host);
 
       // The first component can optionally be '*' to match all subdomains.
       std::vector<std::string> host_components;
       base::SplitString(pattern_.host, kDot, &host_components);
       DCHECK(!host_components.empty());
@@ skipping 23 matching lines @@
   return false;
 }
 
 const std::string& SocketPermissionData::GetAsString() const {
   if (!spec_.empty())
     return spec_;
 
   spec_.reserve(64);
   spec_.append(TypeToString(pattern_.type));
 
+  if (pattern_.type == SocketPermissionRequest::UDP_MUTICAST_MEMBERSHIP)
+    return spec_;
+
   if (match_subdomains_) {
     spec_.append(1, kColon).append(kWildcard);
     if (!pattern_.host.empty())
       spec_.append(1, kDot).append(pattern_.host);
   } else {
      spec_.append(1, kColon).append(pattern_.host);
   }
 
   if (pattern_.port == kWildcardPortNumber)
     spec_.append(1, kColon).append(kWildcard);
   else
     spec_.append(1, kColon).append(base::IntToString(pattern_.port));
 
   return spec_;
 }
 
 void SocketPermissionData::Reset() {
   pattern_.type = SocketPermissionRequest::NONE;
   pattern_.host.clear();
   match_subdomains_ = false;
   pattern_.port = kInvalidPort;
   spec_.clear();
 }
 
 }  // namespace extensions