1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "descriptors.h" 18 19 #include <ctype.h> 20 #include <fcntl.h> 21 #include <sys/stat.h> 22 #include <unistd.h> 23 24 #include <android-base/logging.h> 25 #include <android-base/stringprintf.h> 26 #include <android-base/strings.h> 27 #include <android-base/unique_fd.h> 28 #include <cutils/android_get_control_file.h> 29 #include <cutils/sockets.h> 30 31 #include "init.h" 32 #include "util.h" 33 34 namespace android { 35 namespace init { 36 37 DescriptorInfo::DescriptorInfo(const std::string& name, const std::string& type, uid_t uid, 38 gid_t gid, int perm, const std::string& context) 39 : name_(name), type_(type), uid_(uid), gid_(gid), perm_(perm), context_(context) { 40 } 41 42 DescriptorInfo::~DescriptorInfo() { 43 } 44 45 std::ostream& operator<<(std::ostream& os, const DescriptorInfo& info) { 46 return os << " descriptors " << info.name_ << " " << info.type_ << " " << std::oct << info.perm_; 47 } 48 49 bool DescriptorInfo::operator==(const DescriptorInfo& other) const { 50 return name_ == other.name_ && type_ == other.type_ && key() == other.key(); 51 } 52 53 void DescriptorInfo::CreateAndPublish(const std::string& globalContext) const { 54 // Create 55 const std::string& contextStr = context_.empty() ? globalContext : context_; 56 int fd = Create(contextStr); 57 if (fd < 0) return; 58 59 // Publish 60 std::string publishedName = key() + name_; 61 std::for_each(publishedName.begin(), publishedName.end(), 62 [] (char& c) { c = isalnum(c) ? c : '_'; }); 63 64 std::string val = std::to_string(fd); 65 add_environment(publishedName.c_str(), val.c_str()); 66 67 // make sure we don't close on exec 68 fcntl(fd, F_SETFD, 0); 69 } 70 71 void DescriptorInfo::Clean() const { 72 } 73 74 SocketInfo::SocketInfo(const std::string& name, const std::string& type, uid_t uid, 75 gid_t gid, int perm, const std::string& context) 76 : DescriptorInfo(name, type, uid, gid, perm, context) { 77 } 78 79 void SocketInfo::Clean() const { 80 std::string path = android::base::StringPrintf("%s/%s", ANDROID_SOCKET_DIR, name().c_str()); 81 unlink(path.c_str()); 82 } 83 84 int SocketInfo::Create(const std::string& context) const { 85 auto types = android::base::Split(type(), "+"); 86 int flags = 87 ((types[0] == "stream" ? SOCK_STREAM : (types[0] == "dgram" ? SOCK_DGRAM : SOCK_SEQPACKET))); 88 bool passcred = types.size() > 1 && types[1] == "passcred"; 89 return CreateSocket(name().c_str(), flags, passcred, perm(), uid(), gid(), context.c_str(), 90 sehandle); 91 } 92 93 const std::string SocketInfo::key() const { 94 return ANDROID_SOCKET_ENV_PREFIX; 95 } 96 97 FileInfo::FileInfo(const std::string& name, const std::string& type, uid_t uid, 98 gid_t gid, int perm, const std::string& context) 99 // defaults OK for uid,..., they are ignored for this class. 100 : DescriptorInfo(name, type, uid, gid, perm, context) { 101 } 102 103 int FileInfo::Create(const std::string&) const { 104 int flags = (type() == "r") ? O_RDONLY : 105 (type() == "w") ? O_WRONLY : 106 O_RDWR; 107 108 // Make sure we do not block on open (eg: devices can chose to block on 109 // carrier detect). Our intention is never to delay launch of a service 110 // for such a condition. The service can perform its own blocking on 111 // carrier detect. 112 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(name().c_str(), 113 flags | O_NONBLOCK))); 114 115 if (fd < 0) { 116 PLOG(ERROR) << "Failed to open file '" << name().c_str() << "'"; 117 return -1; 118 } 119 120 // Fixup as we set O_NONBLOCK for open, the intent for fd is to block reads. 121 fcntl(fd, F_SETFL, flags); 122 123 LOG(INFO) << "Opened file '" << name().c_str() << "'" 124 << ", flags " << std::oct << flags << std::dec; 125 126 return fd.release(); 127 } 128 129 const std::string FileInfo::key() const { 130 return ANDROID_FILE_ENV_PREFIX; 131 } 132 133 } // namespace init 134 } // namespace android 135
