SystemConfiguration.fproj/SCDSet.c

   1 /*
   2  * Copyright (c) 2000-2003 Apple Computer, 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 /*
  25  * Modification History
  26  *
  27  * June 1, 2001                 Allan Nathanson <ajn@apple.com>
  28  * - public API conversion
  29  *
  30  * March 24, 2000               Allan Nathanson <ajn@apple.com>
  31  * - initial revision
  32  */
  33
  34 #include <mach/mach.h>
  35 #include <mach/mach_error.h>
  36
  37 #include <SystemConfiguration/SystemConfiguration.h>
  38 #include <SystemConfiguration/SCPrivate.h>
  39 #include "SCDynamicStoreInternal.h"
  40 #include "config.h"             /* MiG generated file */
  41
  42
  43 Boolean
  44 SCDynamicStoreSetMultiple(SCDynamicStoreRef     store,
  45                           CFDictionaryRef       keysToSet,
  46                           CFArrayRef            keysToRemove,
  47                           CFArrayRef            keysToNotify)
  48 {
  49         SCDynamicStorePrivateRef        storePrivate = (SCDynamicStorePrivateRef)store;
  50         kern_return_t                   status;
  51         CFDataRef                       xmlSet          = NULL; /* key/value pairs to set (XML serialized) */
  52         xmlData_t                       mySetRef        = NULL; /* key/value pairs to set (serialized) */
  53         CFIndex                         mySetLen        = 0;
  54         CFDataRef                       xmlRemove       = NULL; /* keys to remove (XML serialized) */
  55         xmlData_t                       myRemoveRef     = NULL; /* keys to remove (serialized) */
  56         CFIndex                         myRemoveLen     = 0;
  57         CFDataRef                       xmlNotify       = NULL; /* keys to notify (XML serialized) */
  58         xmlData_t                       myNotifyRef     = NULL; /* keys to notify (serialized) */
  59         CFIndex                         myNotifyLen     = 0;
  60         int                             sc_status;
  61
  62         if (store == NULL) {
  63                 /* sorry, you must provide a session */
  64                 _SCErrorSet(kSCStatusNoStoreSession);
  65                 return FALSE;
  66         }
  67
  68         if (storePrivate->server == MACH_PORT_NULL) {
  69                 _SCErrorSet(kSCStatusNoStoreServer);
  70                 return FALSE;   /* you must have an open session to play */
  71         }
  72
  73         /* serialize the key/value pairs to set*/
  74         if (keysToSet) {
  75                 CFDictionaryRef newInfo;
  76                 Boolean         ok;
  77
  78                 newInfo = _SCSerializeMultiple(keysToSet);
  79                 if (!newInfo) {
  80                         _SCErrorSet(kSCStatusFailed);
  81                         return FALSE;
  82                 }
  83
  84                 ok = _SCSerialize(newInfo, &xmlSet, (void **)&mySetRef, &mySetLen);
  85                 CFRelease(newInfo);
  86
  87                 if (!ok) {
  88                         _SCErrorSet(kSCStatusFailed);
  89                         return FALSE;
  90                 }
  91         }
  92
  93         /* serialize the keys to remove */
  94         if (keysToRemove) {
  95                 if (!_SCSerialize(keysToRemove, &xmlRemove, (void **)&myRemoveRef, &myRemoveLen)) {
  96                         if (xmlSet)     CFRelease(xmlSet);
  97                         _SCErrorSet(kSCStatusFailed);
  98                         return FALSE;
  99                 }
 100         }
 101
 102         /* serialize the keys to notify */
 103         if (keysToNotify) {
 104                 if (!_SCSerialize(keysToNotify, &xmlNotify, (void **)&myNotifyRef, &myNotifyLen)) {
 105                         if (xmlSet)     CFRelease(xmlSet);
 106                         if (xmlRemove)  CFRelease(xmlRemove);
 107                         _SCErrorSet(kSCStatusFailed);
 108                         return FALSE;
 109                 }
 110         }
 111
 112         /* send the keys and patterns, fetch the associated result from the server */
 113         status = configset_m(storePrivate->server,
 114                              mySetRef,
 115                              mySetLen,
 116                              myRemoveRef,
 117                              myRemoveLen,
 118                              myNotifyRef,
 119                              myNotifyLen,
 120                              (int *)&sc_status);
 121
 122         /* clean up */
 123         if (xmlSet)     CFRelease(xmlSet);
 124         if (xmlRemove)  CFRelease(xmlRemove);
 125         if (xmlNotify)  CFRelease(xmlNotify);
 126
 127         if (status != KERN_SUCCESS) {
 128 #ifdef  DEBUG
 129                 if (status != MACH_SEND_INVALID_DEST)
 130                         SCLog(_sc_verbose, LOG_DEBUG, CFSTR("SCDynamicStoreSetMultiple configset_m(): %s"), mach_error_string(status));
 131 #endif  /* DEBUG */
 132                 (void) mach_port_destroy(mach_task_self(), storePrivate->server);
 133                 storePrivate->server = MACH_PORT_NULL;
 134                 _SCErrorSet(status);
 135                 return FALSE;
 136         }
 137
 138         if (sc_status != kSCStatusOK) {
 139                 _SCErrorSet(sc_status);
 140                 return FALSE;
 141         }
 142
 143         return TRUE;
 144 }
 145
 146 Boolean
 147 SCDynamicStoreSetValue(SCDynamicStoreRef store, CFStringRef key, CFPropertyListRef value)
 148 {
 149         SCDynamicStorePrivateRef        storePrivate = (SCDynamicStorePrivateRef)store;
 150         kern_return_t                   status;
 151         CFDataRef                       utfKey;         /* serialized key */
 152         xmlData_t                       myKeyRef;
 153         CFIndex                         myKeyLen;
 154         CFDataRef                       xmlData;        /* serialized data */
 155         xmlData_t                       myDataRef;
 156         CFIndex                         myDataLen;
 157         int                             sc_status;
 158         int                             newInstance;
 159
 160         if (store == NULL) {
 161                 /* sorry, you must provide a session */
 162                 _SCErrorSet(kSCStatusNoStoreSession);
 163                 return FALSE;
 164         }
 165
 166         if (storePrivate->server == MACH_PORT_NULL) {
 167                 /* sorry, you must have an open session to play */
 168                 _SCErrorSet(kSCStatusNoStoreServer);
 169                 return FALSE;
 170         }
 171
 172         /* serialize the key */
 173         if (!_SCSerializeString(key, &utfKey, (void **)&myKeyRef, &myKeyLen)) {
 174                 _SCErrorSet(kSCStatusFailed);
 175                 return FALSE;
 176         }
 177
 178         /* serialize the data */
 179         if (!_SCSerialize(value, &xmlData, (void **)&myDataRef, &myDataLen)) {
 180                 CFRelease(utfKey);
 181                 _SCErrorSet(kSCStatusFailed);
 182                 return FALSE;
 183         }
 184
 185         /* send the key & data to the server, get new instance id */
 186         status = configset(storePrivate->server,
 187                            myKeyRef,
 188                            myKeyLen,
 189                            myDataRef,
 190                            myDataLen,
 191                            0,
 192                            &newInstance,
 193                            (int *)&sc_status);
 194
 195         /* clean up */
 196         CFRelease(utfKey);
 197         CFRelease(xmlData);
 198
 199         if (status != KERN_SUCCESS) {
 200 #ifdef  DEBUG
 201                 if (status != MACH_SEND_INVALID_DEST)
 202                         SCLog(_sc_verbose, LOG_DEBUG, CFSTR("SCDynamicStoreSetValue configset(): %s"), mach_error_string(status));
 203 #endif  /* DEBUG */
 204                 (void) mach_port_destroy(mach_task_self(), storePrivate->server);
 205                 storePrivate->server = MACH_PORT_NULL;
 206                 _SCErrorSet(status);
 207                 return FALSE;
 208         }
 209
 210         if (sc_status != kSCStatusOK) {
 211                 _SCErrorSet(sc_status);
 212                 return FALSE;
 213         }
 214
 215         return TRUE;
 216 }