The Tor Browser: hal/gonk/UeventPoller.cpp@129ffea94266 (annotated)

hal/gonk/UeventPoller.cpp@129ffea94266 (annotated)

hal/gonk/UeventPoller.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* Copyright 2012 Mozilla Foundation and Mozilla contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
 #include <string.h>
 #include <strings.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <linux/types.h>
 #include <linux/netlink.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include "nsDebug.h"
 #include "base/message_loop.h"
 #include "mozilla/FileUtils.h"
 #include "nsAutoPtr.h"
 #include "nsThreadUtils.h"
 #include "nsXULAppAPI.h"
 #include "UeventPoller.h"
 namespace mozilla {
 namespace hal_impl {
 static void ShutdownUevent();
 class NetlinkPoller : public MessageLoopForIO::Watcher
 {
 public:
   NetlinkPoller() : mSocket(-1),
                     mIOLoop(MessageLoopForIO::current())
   {
   }
   virtual ~NetlinkPoller() {}
   bool OpenSocket();
   virtual void OnFileCanReadWithoutBlocking(int fd);
   // no writing to the netlink socket
   virtual void OnFileCanWriteWithoutBlocking(int fd)
   {
     MOZ_CRASH("Must not write to netlink socket");
   }
   MessageLoopForIO *GetIOLoop () const { return mIOLoop; }
   void RegisterObserver(IUeventObserver *aObserver)
   {
     mUeventObserverList.AddObserver(aObserver);
   }
   void UnregisterObserver(IUeventObserver *aObserver)
   {
     mUeventObserverList.RemoveObserver(aObserver);
     if (mUeventObserverList.Length() == 0)
       ShutdownUevent();  // this will destroy self
   }
 private:
   ScopedClose mSocket;
   MessageLoopForIO* mIOLoop;
   MessageLoopForIO::FileDescriptorWatcher mReadWatcher;
   const static int kBuffsize = 64 * 1024;
   uint8_t mBuffer [kBuffsize];
   typedef ObserverList<NetlinkEvent> UeventObserverList;
   UeventObserverList mUeventObserverList;
 };
 bool
 NetlinkPoller::OpenSocket()
 {
   mSocket.rwget() = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
   if (mSocket.get() < 0)
     return false;
   int sz = kBuffsize;
   if (setsockopt(mSocket.get(), SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)) < 0)
     return false;
   // add FD_CLOEXEC flag
   int flags = fcntl(mSocket.get(), F_GETFD);
   if (flags == -1) {
       return false;
   }
   flags |= FD_CLOEXEC;
   if (fcntl(mSocket.get(), F_SETFD, flags) == -1)
     return false;
   // set non-blocking
   if (fcntl(mSocket.get(), F_SETFL, O_NONBLOCK) == -1)
     return false;
   struct sockaddr_nl saddr;
   bzero(&saddr, sizeof(saddr));
   saddr.nl_family = AF_NETLINK;
   saddr.nl_groups = 1;
   saddr.nl_pid = gettid();
   do {
     if (bind(mSocket.get(), (struct sockaddr *)&saddr, sizeof(saddr)) == 0) {
       break;
     }
     if (errno != EADDRINUSE) {
       return false;
     }
     if (saddr.nl_pid == 0) {
       return false;
     }
     // Once there was any other place in the same process assigning saddr.nl_pid by
     // gettid(), we can detect it and print warning message.
     printf_stderr("The netlink socket address saddr.nl_pid=%u is in use. Let the kernel re-assign.\n", saddr.nl_pid);
     saddr.nl_pid = 0;
   } while (true);
   if (!mIOLoop->WatchFileDescriptor(mSocket.get(),
                                     true,
                                     MessageLoopForIO::WATCH_READ,
                                     &mReadWatcher,
                                     this)) {
       return false;
   }
   return true;
 }
 static nsAutoPtr<NetlinkPoller> sPoller;
 class UeventInitTask : public Task
 {
   virtual void Run()
   {
     if (!sPoller) {
       return;
     }
     if (sPoller->OpenSocket()) {
       return;
     }
     sPoller->GetIOLoop()->PostDelayedTask(FROM_HERE, new UeventInitTask(), 1000);
   }
 };
 void
 NetlinkPoller::OnFileCanReadWithoutBlocking(int fd)
 {
   MOZ_ASSERT(fd == mSocket.get());
   while (true) {
     int ret = read(fd, mBuffer, kBuffsize);
     if (ret == -1) {
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
         return;
       }
       if (errno == EINTR) {
         continue;
       }
     }
     if (ret <= 0) {
       // fatal error on netlink socket which should not happen
       _exit(1);
     }
     NetlinkEvent netlinkEvent;
     netlinkEvent.decode(reinterpret_cast<char*>(mBuffer), ret);
     mUeventObserverList.Broadcast(netlinkEvent);
   }
 }
 static void
 InitializeUevent()
 {
   MOZ_ASSERT(!sPoller);
   sPoller = new NetlinkPoller();
   sPoller->GetIOLoop()->PostTask(FROM_HERE, new UeventInitTask());
 }
 static void
 ShutdownUevent()
 {
   sPoller = nullptr;
 }
 void
 RegisterUeventListener(IUeventObserver *aObserver)
 {
   MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop());
   if (!sPoller)
     InitializeUevent();
   sPoller->RegisterObserver(aObserver);
 }
 void
 UnregisterUeventListener(IUeventObserver *aObserver)
 {
   MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop());
   sPoller->UnregisterObserver(aObserver);
 }
 } // hal_impl
 } // mozilla

The Tor Browser / annotate

hal/gonk/UeventPoller.cpp@129ffea94266 (annotated)

hal/gonk/UeventPoller.cpp