1  /*
  2   * Copyright (c) 2016-2017 Apple Inc. All Rights Reserved.
  3   *
  4   * @APPLE_LICENSE_HEADER_START@
  5   *
  6   * This file contains Original Code and/or Modifications of Original Code
  7   * as defined in and that are subject to the Apple Public Source License
  8   * Version 2.0 (the 'License'). You may not use this file except in
  9   * compliance with the License. Please obtain a copy of the License at
 10   * http://www.opensource.apple.com/apsl/ and read it before using this
 11   * file.
 12   *
 13   * The Original Code and all software distributed under the License are
 14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 18   * Please see the License for the specific language governing rights and
 19   * limitations under the License.
 20   *
 21   * @APPLE_LICENSE_HEADER_END@
 22   */
 23  
 24  #include "SharedMemoryServer.h"
 25  #include <stdlib.h>
 26  #include <sys/mman.h>
 27  #include <sys/errno.h>
 28  #include <fcntl.h>
 29  #include <machine/byte_order.h>
 30  #include <string>
 31  #include <sys/stat.h>
 32  #include <security_utilities/crc.h>
 33  #include <security_utilities/casts.h>
 34  #include <unistd.h>
 35  #include <vector>
 36  
 37  /*
 38      Logically, these should go in /var/run/mds, but we know that /var/db/mds
 39      already exists at install time.
 40  */
 41  
 42  static bool makedir(const char *path, mode_t mode) {
 43      // Returns true on success. Primarily to centralize logging
 44      if (::mkdir(path, mode)==0 || errno==EEXIST) {
 45          return true;
 46      } else {
 47          secdebug("MDSPRIVACY","Failed to make directory: %s (%d)", path, errno);
 48          return false;
 49      }
 50  }
 51  
 52  static void unlinkfile(const char *path) {
 53      // Primarily to centralize logging
 54      if (::unlink(path)==-1) {
 55           secdebug("MDSPRIVACY","Failed to unlink file: %s (%d)", path, errno);
 56      }
 57  }
 58  
 59  SharedMemoryServer::SharedMemoryServer (const char* segmentName, SegmentOffsetType segmentSize, uid_t uid, gid_t gid) :
 60      mSegmentName (segmentName), mSegmentSize (segmentSize), mUID(SharedMemoryCommon::fixUID(uid))
 61  {
 62      const mode_t perm1777 = S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO;
 63      const mode_t perm0755 = S_IRWXU | (S_IRGRP | S_IXGRP) | (S_IROTH | S_IXOTH);
 64      const mode_t perm0600 = (S_IRUSR | S_IWUSR);
 65  
 66      // make the mds directory, just in case it doesn't exist
 67      if (mUID == 0) {
 68          makedir(SharedMemoryCommon::kMDSDirectory, perm1777);
 69          makedir(SharedMemoryCommon::kMDSMessagesDirectory, perm0755);
 70      } else {
 71          // Assume kMDSMessagesDirectory was created first by securityd
 72          std::string uidstr = std::to_string(mUID);
 73          std::string upath = SharedMemoryCommon::kMDSMessagesDirectory;
 74          upath += "/" + uidstr;
 75          makedir(upath.c_str(), perm0755);
 76      }
 77      mFileName = SharedMemoryCommon::SharedMemoryFilePath(segmentName, uid);
 78  
 79      // make the file name
 80      // clean any old file away
 81      unlinkfile(mFileName.c_str());
 82  
 83      // open the file
 84      secdebug("MDSPRIVACY","creating %s",mFileName.c_str ());
 85      if(mUID != 0) {
 86          mBackingFile = open (mFileName.c_str (), O_RDWR | O_CREAT | O_EXCL, perm0600);
 87      }
 88      else {
 89          mBackingFile = open (mFileName.c_str (), O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 90      }
 91  
 92      if (mBackingFile < 0)
 93      {
 94          secdebug("MDSPRIVACY","creation of %s failed", mFileName.c_str());
 95          return;
 96      }
 97  
 98      int rx = fchown(mBackingFile, uid, gid);
 99      if (rx) {
100          secdebug("MDSPRIVACY","chown of %s to %d/%d failed : %d", mFileName.c_str(), uid, gid, rx);
101      }
102  
103      // set the segment size
104      ftruncate (mBackingFile, segmentSize);
105      
106      // map it into memory
107      mSegment = (u_int8_t*) mmap (NULL, mSegmentSize, PROT_READ | PROT_WRITE, MAP_SHARED, mBackingFile, 0);
108  
109      if (mSegment == MAP_FAILED) // can't map the memory?
110      {
111          mSegment = NULL;
112          unlinkfile(mFileName.c_str());
113      } else {
114          mDataPtr = mDataArea = mSegment + sizeof(SegmentOffsetType);
115          mDataMax = mSegment + segmentSize;;
116  
117          SetProducerOffset (0);
118      }
119  }
120  
121  SharedMemoryServer::~SharedMemoryServer ()
122  {
123  	// go away
124  	if (mSegment == NULL)
125  	{
126  		return;
127  	}
128  	
129  	// get out of memory
130  	munmap (mSegment, mSegmentSize);
131  
132      close(mBackingFile);
133  	
134  	// mark the segment for deletion
135  	unlinkfile(mFileName.c_str ());
136  }
137  
138  
139  
140  const SegmentOffsetType
141  	kSegmentLength = 0,
142  	kCRCOffset = kSegmentLength + sizeof(SegmentOffsetType),
143  	kDomainOffset = kCRCOffset + sizeof(SegmentOffsetType),
144  	kEventTypeOffset = kDomainOffset + sizeof(SegmentOffsetType),
145  	kHeaderLength = kEventTypeOffset + sizeof(SegmentOffsetType) - kCRCOffset;
146  
147  void SharedMemoryServer::WriteMessage (SegmentOffsetType domain, SegmentOffsetType event, const void *message, SegmentOffsetType messageLength)
148  {
149      // backing file MUST be right size, don't ftruncate() more then needed though to avoid reaching too deep into filesystem
150      struct stat sb;
151      if (::fstat(mBackingFile, &sb) == 0 && sb.st_size != (off_t)mSegmentSize) {
152          ::ftruncate(mBackingFile, mSegmentSize);
153      }
154  
155  	// assemble the final message
156  	ssize_t messageSize = kHeaderLength + messageLength;
157  	std::vector<u_int8_t> finalMessage(messageSize);
158  	SegmentOffsetType *fm  = (SegmentOffsetType*) finalMessage.data();
159  	fm[0] = OSSwapHostToBigInt32(domain);
160  	fm[1] = OSSwapHostToBigInt32(event);
161  	memcpy(&fm[2], message, messageLength);
162  	
163  	SegmentOffsetType crc = CalculateCRC(finalMessage.data(), messageSize);
164  	
165  	// write the length
166  	WriteOffset(int_cast<size_t, SegmentOffsetType>(messageSize));
167  	
168  	// write the crc
169  	WriteOffset(crc);
170  	
171  	// write the data
172  	WriteData (finalMessage.data(), int_cast<size_t, SegmentOffsetType>(messageSize));
173  	
174  	// write the data count
175  	SetProducerOffset(int_cast<size_t, SegmentOffsetType>(mDataPtr - mDataArea));
176  }
177  
178  
179  
180  const char* SharedMemoryServer::GetSegmentName ()
181  {
182  	return mSegmentName.c_str ();
183  }
184  
185  
186  
187  size_t SharedMemoryServer::GetSegmentSize ()
188  {
189  	return mSegmentSize;
190  }
191  
192  
193  void SharedMemoryServer::SetProducerOffset (SegmentOffsetType producerCount)
194  {
195  	*((SegmentOffsetType*) mSegment) = OSSwapHostToBigInt32 (producerCount);
196  }
197  
198  
199  
200  void SharedMemoryServer::WriteOffset(SegmentOffsetType offset)
201  {
202  	u_int8_t buffer[4];
203  	*((u_int32_t*) buffer) = OSSwapHostToBigInt32(offset);
204  	WriteData(buffer, 4);
205  }
206  
207  
208  
209  void SharedMemoryServer::WriteData(const void* data, SegmentOffsetType length)
210  {
211  	// figure out where in the buffer we actually need to write the data
212  	// figure out how many bytes we can write without overflowing the buffer
213  	const u_int8_t* dp = (const u_int8_t*) data;
214  	SegmentOffsetType bytesToEnd = int_cast<ptrdiff_t, SegmentOffsetType>(mDataMax - mDataPtr);
215  	
216  	// figure out how many bytes we can write
217  	SegmentOffsetType bytesToWrite = (length <= bytesToEnd) ? length : bytesToEnd;
218  
219  	// move the first part of the data, making sure to skip the producer pointer
220  	memcpy (mDataPtr, dp, bytesToWrite);
221  	mDataPtr += bytesToWrite;
222  	dp += bytesToWrite;
223  	
224  	// deduct the bytes just written
225  	length -= bytesToWrite;
226  	
227  	if (length != 0) // did we wrap around?
228  	{
229  		mDataPtr = mDataArea;
230  		memcpy (mDataPtr, dp, length);
231  		mDataPtr += length;
232  	}
233  }