src/platform/DARWIN/AFSPreference/afshlp.m

   1 //
   2 //  afshlp.m
   3 //  AFSCommander
   4 //
   5 //  Created by Claudio on 28/06/07.
   6 //
   7
   8
   9 #include <sys/types.h>
  10 #include <unistd.h>
  11 #include <Security/Authorization.h>
  12 #include <Security/AuthorizationTags.h>
  13 #include <sys/param.h>
  14 #include <sys/stat.h>
  15 #include <sys/wait.h>
  16 #include <sys/types.h>
  17 #include <sys/fcntl.h>
  18 #include <sys/errno.h>
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <asl.h>
  23 #include <sys/event.h>
  24 #include <mach-o/dyld.h>
  25 #import "TaskUtil.h"
  26 #import "AuthUtil.h"
  27 #import "PListManager.h"
  28  void stopAfs(int argc, char *argv[]);
  29  void getPath(char **selfPathPtr);
  30  void selfRepair(char *selfPath);
  31  void runWithSelfRepair(char *selfPath,int argc, char *argv[]);
  32  void runCommand(int argc, char *argv[]);
  33
  34 int main(int argc, char *argv[])
  35 {
  36         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  37     char *selfPath;
  38
  39         NSLog(@"num of arguments %d", argc);
  40         int status = [[AuthUtil shared] autorize];
  41         if(status != noErr) exit(-1);
  42
  43     // Get the path to the tool's executable
  44     getPath(&selfPath);
  45
  46     //selfRepair(selfPath);
  47     // All done with the executable path
  48     if(selfPath) free(selfPath);
  49
  50         // Now do the real work of running the command.
  51     runCommand(argc, argv);
  52     [[AuthUtil shared] deautorize];
  53     [pool release];
  54
  55         return 0;
  56 }
  57
  58 //
  59 void runCommand(int argc, char *argv[])
  60 {
  61         NSString *cmdString = [NSString stringWithCString:(const char *)argv[1] encoding:NSUTF8StringEncoding];
  62
  63         if(argc == 4 && [cmdString rangeOfString:@"stop_afs"].location!=NSNotFound ){
  64                 NSLog(@"Stop afs from helper");
  65                 stopAfs(argc, argv);
  66         } else  if(argc == 4 && [cmdString rangeOfString:@"start_afs"].location!=NSNotFound){
  67                 NSLog(@"Start afs from helper");
  68                 setuid(0);
  69                 const char *startArgs[] = {argv[2], argv[3], 0L};
  70                 [[AuthUtil shared] execUnixCommand:argv[1]
  71                                                                           args:startArgs
  72                                                                         output:nil];
  73         } else if(argc == 4 && [cmdString rangeOfString:@"enable_krb5_startup"].location!=NSNotFound) {
  74                 NSLog(@"Manage KRB5 at login time with option %s from helper", argv[2]);
  75                 setuid(0);
  76                 int arg2 = atoi(argv[2]);
  77                 [PListManager krb5TiketAtLoginTime:[[NSNumber numberWithInt:arg2] boolValue]];
  78
  79         } else if(argc == 5 && [cmdString rangeOfString:@"start_afs_at_startup"].location!=NSNotFound){
  80                 setuid(0);
  81                 NSLog(@"Manage start_afs_at_startup with option %s from helper", argv[2]);
  82                 [PListManager manageAfsStartupLaunchdFile:YES
  83                                                                  afsStartupScript:[NSString stringWithCString:argv[2]]
  84                                                                           afsBasePath:[NSString stringWithCString:argv[4]]
  85                                                                                  afsdPath:[NSString stringWithCString:argv[3]]];
  86         }
  87 }
  88
  89 void stopAfs(int argc, char *argv[])
  90 {
  91
  92
  93         setuid(0);
  94         const char *umountArgs[] = {"-f", "/afs", 0L};
  95         [[AuthUtil shared] execUnixCommand:"/sbin/umount"
  96                                                                   args:umountArgs
  97                                                                 output:nil];
  98
  99         const char *afsdArgs[] = {"-shutdown", 0L};
 100         [[AuthUtil shared] execUnixCommand:argv[3]
 101                                                                   args:afsdArgs
 102                                                                 output:nil];
 103
 104         const char *kernelExtArgs[] = {argv[2], 0L};
 105         [[AuthUtil shared] execUnixCommand:"/sbin/kextunload"
 106                                                                   args:kernelExtArgs
 107                                                                 output:nil];
 108
 109         [[AuthUtil shared] deautorize];
 110 }
 111
 112
 113 // Code to get the path to the executable using _NSGetExecutablePath.
 114 void getPath(char **selfPathPtr)
 115 {
 116     uint32_t selfPathSize = MAXPATHLEN;
 117     if(!(*selfPathPtr = malloc(selfPathSize)))
 118     {
 119         exit(-1);
 120     }
 121     if(_NSGetExecutablePath(*selfPathPtr, &selfPathSize) == -1)
 122     {
 123         // Try reallocating selfPath with the size returned by the function.
 124         if(!(*selfPathPtr = realloc(*selfPathPtr, selfPathSize + 1)))
 125         {
 126             NSLog(@"Could not allocate memory to hold executable path.");
 127             exit(-1);
 128         }
 129         if(_NSGetExecutablePath(*selfPathPtr, &selfPathSize) != 0)
 130         {
 131             NSLog(@"Could not get executable path.");
 132             exit(-1);
 133         }
 134     }
 135 }
 136
 137 // Self-repair code. Found somehwere in internet
 138 void selfRepair(char *selfPath)
 139 {
 140     struct stat st;
 141     int fdTool;
 142         printf("selfRepair");
 143
 144 //    [[AuthUtil shared] autorize];
 145
 146     // Open tool exclusively, noone can touch it when we work on it, this idea i kepped somewhere in internet
 147     fdTool = open(selfPath, O_NONBLOCK | O_RDONLY | O_EXLOCK, 0);
 148
 149     if(fdTool == -1)
 150     {
 151         NSLog(@"Open Filed: %d.", errno);
 152         exit(-1);
 153     }
 154
 155     if(fstat(fdTool, &st))
 156     {
 157         NSLog(@"fstat failed.");
 158         exit(-1);
 159     }
 160
 161     if(st.st_uid != 0)
 162     {
 163         fchown(fdTool, 0, st.st_gid);
 164     } else  NSLog(@"st_uid = 0");
 165
 166     // Disable group and world writability and make setuid root.
 167     fchmod(fdTool, (st.st_mode & (~(S_IWGRP | S_IWOTH))) | S_ISUID);
 168
 169     close(fdTool);
 170
 171     NSLog(@"Self-repair done.");
 172 }
 173
 174
 175 // Code to execute the tool in self-repair mode.
 176 void runWithSelfRepair(char *selfPath, int argc, char *argv[])
 177 {
 178     int status;
 179     int pid;
 180
 181
 182         // Make the qargs array for passing to child the same args of father
 183     const char *arguments[] = {argv[1], argv[2], argv[3], "--self-repair", 0L};
 184
 185         // Get the privileged AuthorizationRef
 186     [[AuthUtil shared] autorize];
 187         [[AuthUtil shared] execUnixCommand:selfPath
 188                                                                   args:arguments
 189                                                                 output:nil];
 190
 191     pid = wait(&status);
 192     if(pid == -1 || !WIFEXITED(status))
 193     {
 194         NSLog(@"Error returned from wait().");
 195         exit(-1);
 196     }
 197
 198     // Exit with the same exit code as the self-repair child
 199     exit(WEXITSTATUS(status));
 200 }