static void
wait_for_servers(void)
{
int i;
int retry_count = 10;
mach_port_t bsport, servport;
kern_return_t ret;
/* find server port */
ret = task_get_bootstrap_port(mach_task_self(), &bsport);
if (KERN_SUCCESS != ret) {
mach_error("task_get_bootstrap_port(): ", ret);
exit(1);
}
while (retry_count-- > 0) {
for (i = 0; i < num_servers; i++) {
ret = bootstrap_look_up(bsport,
server_port_name[i],
&servport);
if (ret != KERN_SUCCESS) {
break;
}
}
if (ret == KERN_SUCCESS)
return;
usleep(100 * 1000); /* 100ms */
}
fprintf(stderr, "Server(s) failed to register\n");
exit(1);
}
STATIC mach_port_t
eapolcfg_auth_server_port(void)
{
kern_return_t kret;
mach_port_t server;
#ifdef BOOTSTRAP_PRIVILEGED_SERVER
kret = bootstrap_look_up2(bootstrap_port,
EAPOLCFG_AUTH_SERVER,
&server,
0,
BOOTSTRAP_PRIVILEGED_SERVER);
#else /* BOOTSTRAP_PRIVILEGED_SERVER */
kret = bootstrap_look_up(bootstrap_port, EAPOLCFG_AUTH_SERVER, server_p);
#endif /* BOOTSTRAP_PRIVILEGED_SERVER */
if (kret != BOOTSTRAP_SUCCESS) {
/* just to make sure */
server = MACH_PORT_NULL;
EAPLOG(LOG_NOTICE, "EAPOLClientItemID: can't lookup eapolcfg_auth");
}
return (server);
}
static void _INXPortInit() {
if (!INXIsSpringBoard()) {
kern_return_t err = bootstrap_look_up(bootstrap_port, "hk.kennytm.iNotifyEx.server", &_port);
if (err)
CFLog(kCFLogLevelError, CFSTR("iNotifyEx: Fail to look up service \"hk.kennytm.iNotifyEx.server\": %s"), mach_error_string(err));
}
}
Boolean IOUPSMIGServerIsRunning(mach_port_t * bootstrap_port_ref, mach_port_t * upsd_port_ref)
{
mach_port_t active = MACH_PORT_NULL;
kern_return_t kern_result = KERN_SUCCESS;
mach_port_t bootstrap_port;
if (bootstrap_port_ref && (*bootstrap_port_ref != MACH_PORT_NULL)) {
bootstrap_port = *bootstrap_port_ref;
} else {
/* Get the bootstrap server port */
kern_result = task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
if (kern_result != KERN_SUCCESS) {
return false;
}
if (bootstrap_port_ref) {
*bootstrap_port_ref = bootstrap_port;
}
}
/* Check "upsd" server status */
kern_result = bootstrap_look_up(
bootstrap_port,
kIOUPSPlugInServerName,
&active);
if (BOOTSTRAP_SUCCESS == kern_result) {
return true;
} else {
// For any result other than SUCCESS, we presume the server is
// not running. We expect the most common failure result to be:
// kern_result == BOOTSTRAP_UNKNOWN_SERVICE
return false;
}
}
/*
* kern_return_t
* bootstrap_look_up(mach_port_t bootstrap_port,
* name_t service_name,
* mach_port_t *service_portp)
*
* Returns send rights for the service port of the service named by
* service_name in *service_portp. Service is not guaranteed to be active.
*
* Errors: Returns appropriate kernel errors on rpc failure.
* Returns BOOTSTRAP_UNKNOWN_SERVICE, if service does not exist.
*/
kern_return_t
x_bootstrap_look_up(
mach_port_t bootstrap_port,
name_t service_name,
mach_port_t *service_portp)
{
service_t *servicep;
bootstrap_info_t *bootstrap;
bootstrap = lookup_bootstrap_by_port(bootstrap_port);
servicep = lookup_service_by_name(bootstrap, service_name);
if (servicep == NULL || servicep->port == MACH_PORT_NULL) {
if (forward_ok) {
debug("bootstrap_look_up service %s forwarding",
service_name);
return bootstrap_look_up(inherited_bootstrap_port,
service_name,
service_portp);
} else {
debug("bootstrap_look_up service %s unknown",
service_name);
return BOOTSTRAP_UNKNOWN_SERVICE;
}
}
*service_portp = servicep->port;
debug("Lookup returns port %x for service %s",
servicep->port,
servicep->name);
return BOOTSTRAP_SUCCESS;
}
/* send our task port to the server */
static void send_server_task_port(void)
{
mach_port_t bootstrap_port, wineserver_port;
kern_return_t kret;
struct {
mach_msg_header_t header;
mach_msg_body_t body;
mach_msg_port_descriptor_t task_port;
} msg;
if (task_get_bootstrap_port(mach_task_self(), &bootstrap_port) != KERN_SUCCESS) return;
kret = bootstrap_look_up(bootstrap_port, (char*)wine_get_server_dir(), &wineserver_port);
if (kret != KERN_SUCCESS)
fatal_error( "cannot find the server port: 0x%08x\n", kret );
mach_port_deallocate(mach_task_self(), bootstrap_port);
msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
msg.header.msgh_size = sizeof(msg);
msg.header.msgh_remote_port = wineserver_port;
msg.header.msgh_local_port = MACH_PORT_NULL;
msg.body.msgh_descriptor_count = 1;
msg.task_port.name = mach_task_self();
msg.task_port.disposition = MACH_MSG_TYPE_COPY_SEND;
msg.task_port.type = MACH_MSG_PORT_DESCRIPTOR;
kret = mach_msg_send(&msg.header);
if (kret != KERN_SUCCESS)
server_protocol_error( "mach_msg_send failed: 0x%08x\n", kret );
mach_port_deallocate(mach_task_self(), wineserver_port);
}
mach_port_t sharkctl_create_port(void) {
mach_port_t bootstrap_port, shark_port = 0;
task_get_special_port(mach_task_self(), TASK_BOOTSTRAP_PORT,
&bootstrap_port);
bootstrap_look_up(bootstrap_port, "CHUD_IPC", &shark_port);
return shark_port;
}
static int
mach_lookup(const char *name, xpc_port_t *local, xpc_port_t *remote)
{
mach_port_t mp, rmp;
kern_return_t kr;
kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE,
&mp);
if (kr != KERN_SUCCESS) {
errno = EPERM;
return (-1);
}
kr = mach_port_insert_right(mach_task_self(), mp, mp,
MACH_MSG_TYPE_MAKE_SEND);
if (kr != KERN_SUCCESS) {
errno = EPERM;
return (-1);
}
kr = bootstrap_look_up(bootstrap_port, name, &rmp);
if (kr != KERN_SUCCESS) {
debugf("bootstrap_look_up failed kr=%d", kr);
errno = EBUSY;
return (-1);
}
*local = (xpc_port_t)mp;
*remote = (xpc_port_t)rmp;
return (0);
}
static mach_port_t getHelperPort(int retry)
{
static mach_port_t port = MACH_PORT_NULL;
if (retry) port = MACH_PORT_NULL;
if (port == MACH_PORT_NULL && BOOTSTRAP_SUCCESS != bootstrap_look_up(bootstrap_port, kmDNSHelperServiceName, &port))
LogMsg("%s: cannot contact helper", __func__);
return port;
}
static kern_return_t
look_up(const char *service, mach_port_t *nport)
{
#ifdef __APPLE_PRIVATE__
return bootstrap_look_up2(bootstrap_port, service, nport, 0, BOOTSTRAP_PRIVILEGED_SERVER);
#else
return bootstrap_look_up(bootstrap_port, service, nport);
#endif
}
guint
_frida_electra_policy_softener_internal_jb_connect (void)
{
mach_port_t service_port = MACH_PORT_NULL;
kern_return_t kr;
kr = bootstrap_look_up (bootstrap_port, "org.coolstar.jailbreakd", &service_port);
if (kr != KERN_SUCCESS)
return MACH_PORT_NULL;
return service_port;
}
void* AppleCMIODPSampleNewPlugIn(CFAllocatorRef allocator, CFUUIDRef requestedTypeUUID)
{
if (not CFEqual(requestedTypeUUID, kCMIOHardwarePlugInTypeID))
return 0;
try
{
// Before going any further, make sure the SampleAssistant process is registerred with Mach's bootstrap service. Normally, this would be done by having an appropriately
// configured plist in /Library/LaunchDaemons, but if that is done then the process will be owned by root, thus complicating the debugging process. Therefore, in the event that the
// plist is missing (as would be the case for most debugging efforts) attempt to register the SampleAssistant now. It will fail gracefully if allready registered.
mach_port_t assistantServicePort;
name_t assistantServiceName = "com.apple.cmio.DPA.Sample";
kern_return_t err = bootstrap_look_up(bootstrap_port, assistantServiceName, &assistantServicePort);
if (BOOTSTRAP_SUCCESS != err)
{
// Create an URL to SampleAssistant that resides at "/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant"
CACFURL assistantURL(CFURLCreateWithFileSystemPath(NULL, CFSTR("/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant"), kCFURLPOSIXPathStyle, false));
ThrowIf(not assistantURL.IsValid(), CAException(-1), "AppleCMIODPSampleNewPlugIn: unable to create URL for the SampleAssistant");
// Get the maximum size of the of the file system representation of the SampleAssistant's absolute path
CFIndex length = CFStringGetMaximumSizeOfFileSystemRepresentation(CACFString(CFURLCopyFileSystemPath(CACFURL(CFURLCopyAbsoluteURL(assistantURL.GetCFObject())).GetCFObject(), kCFURLPOSIXPathStyle)).GetCFString());
// Get the file system representation
CAAutoFree<char> path(length);
(void) CFURLGetFileSystemRepresentation(assistantURL.GetCFObject(), true, reinterpret_cast<UInt8*>(path.get()), length);
mach_port_t assistantServerPort;
err = bootstrap_create_server(bootstrap_port, path, getuid(), true, &assistantServerPort);
ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create server");
err = bootstrap_check_in(assistantServerPort, assistantServiceName, &assistantServicePort);
// The server port is no longer needed so get rid of it
(void) mach_port_deallocate(mach_task_self(), assistantServerPort);
// Make sure the call to bootstrap_create_service() succeeded
ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create SampleAssistant service port");
}
// The service port is not longer needed so get rid of it
(void) mach_port_deallocate(mach_task_self(), assistantServicePort);
CMIO::DP::Sample::PlugIn* plugIn = new CMIO::DP::Sample::PlugIn(requestedTypeUUID);
plugIn->Retain();
return plugIn->GetInterface();
}
catch (...)
{
return NULL;
}
}
// lookup a launchd service:
mach_port_t lookup(char* name) {
mach_port_t service_port = MACH_PORT_NULL;
kern_return_t err = bootstrap_look_up(bootstrap_port, name, &service_port);
if(err != KERN_SUCCESS){
printf("unable to look up %s\n", name);
return MACH_PORT_NULL;
}
if (service_port == MACH_PORT_NULL) {
printf("bad service port\n");
return MACH_PORT_NULL;
}
return service_port;
}
static mach_port_t LKDCGetHelperPort(int retry)
{
static mach_port_t port = MACH_PORT_NULL;
if (retry) {
port = MACH_PORT_NULL;
}
if (port == MACH_PORT_NULL &&
BOOTSTRAP_SUCCESS != bootstrap_look_up(bootstrap_port, kLKDCHelperName, &port)) {
LKDCLog("%s: cannot contact helper", __func__);
}
return port;
}
kern_return_t
bootstrap_status(mach_port_t bp, name_t service_name, bootstrap_status_t *service_active)
{
mach_port_t p;
if (bootstrap_check_in(bp, service_name, &p) == BOOTSTRAP_SUCCESS) {
mach_port_mod_refs(mach_task_self(), p, MACH_PORT_RIGHT_RECEIVE, -1);
*service_active = BOOTSTRAP_STATUS_ON_DEMAND;
return BOOTSTRAP_SUCCESS;
} else if (bootstrap_look_up(bp, service_name, &p) == BOOTSTRAP_SUCCESS) {
mach_port_deallocate(mach_task_self(), p);
*service_active = BOOTSTRAP_STATUS_ACTIVE;
return BOOTSTRAP_SUCCESS;
}
return BOOTSTRAP_UNKNOWN_SERVICE;
}
static mach_port_t DNSServiceDiscoveryLookupServer(void)
{
static mach_port_t sndPort = MACH_PORT_NULL;
kern_return_t result;
if (sndPort != MACH_PORT_NULL) {
return sndPort;
}
result = bootstrap_look_up(bootstrap_port, DNS_SERVICE_DISCOVERY_SERVER, &sndPort);
if (result != KERN_SUCCESS) {
printf("%s(): {%s:%d} bootstrap_look_up() failed: $%x\n", __FUNCTION__, __FILE__, __LINE__, (int) result);
sndPort = MACH_PORT_NULL;
}
return sndPort;
}
static mach_port_t
__SCDynamicStoreServerPort(SCDynamicStorePrivateRef storePrivate, kern_return_t *status)
{
mach_port_t server = MACH_PORT_NULL;
char *server_name;
server_name = getenv("SCD_SERVER");
if (server_name == NULL) {
server_name = SCD_SERVER;
}
#if defined(BOOTSTRAP_PRIVILEGED_SERVER) && !TARGET_IPHONE_SIMULATOR
*status = bootstrap_look_up2(bootstrap_port,
server_name,
&server,
0,
BOOTSTRAP_PRIVILEGED_SERVER);
#else // defined(BOOTSTRAP_PRIVILEGED_SERVER) && !TARGET_IPHONE_SIMULATOR
*status = bootstrap_look_up(bootstrap_port, server_name, &server);
#endif // defined(BOOTSTRAP_PRIVILEGED_SERVER) && !TARGET_IPHONE_SIMULATOR
switch (*status) {
case BOOTSTRAP_SUCCESS :
/* service currently registered, "a good thing" (tm) */
return server;
case BOOTSTRAP_NOT_PRIVILEGED :
/* the service is not privileged */
break;
case BOOTSTRAP_UNKNOWN_SERVICE :
/* service not currently registered, try again later */
break;
default :
#ifdef DEBUG
SCLog(_sc_verbose, LOG_DEBUG,
CFSTR("SCDynamicStoreCreate[WithOptions] bootstrap_look_up() failed: status=%s"),
bootstrap_strerror(*status));
#endif /* DEBUG */
break;
}
return MACH_PORT_NULL;
}
static void
_asl_global_init()
{
if (_asl_global.server_port == MACH_PORT_NULL)
{
mach_port_t newport = MACH_PORT_NULL;
char *str = getenv("ASL_DISABLE");
if ((str == NULL) || strcmp(str, "1"))
{
bootstrap_look_up(bootstrap_port, ASL_SERVICE_NAME, &newport);
if (newport != MACH_PORT_NULL)
{
if (!OSAtomicCompareAndSwap32Barrier(MACH_PORT_NULL, newport, (int32_t *)&_asl_global.server_port))
{
mach_port_deallocate(mach_task_self(), newport);
}
}
}
}
}
// Client side : get the published semaphore from server
bool JackMachSemaphore::ConnectInput(const char* name, const char* server_name)
{
BuildName(name, server_name, fName, sizeof(fName));
kern_return_t res;
if (fBootPort == 0) {
if ((res = task_get_bootstrap_port(mach_task_self(), &fBootPort)) != KERN_SUCCESS) {
jack_error("Connect: can't find bootstrap port err = %s", mach_error_string(res));
return false;
}
}
if ((res = bootstrap_look_up(fBootPort, fName, &fSemaphore)) != KERN_SUCCESS) {
jack_error("Connect: can't find mach semaphore name = %s err = %s", fName, mach_error_string(res));
return false;
}
jack_log("JackMachSemaphore::Connect name = %s ", fName);
return true;
}
int client_main(void) {
kern_return_t kr;
mach_port_t mp;
kr = bootstrap_look_up(bootstrap_port, BOOTSTRAP_NAME, &mp);
if (kr != KERN_SUCCESS) {
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
fprintf(stderr, "privileged_startx: bootstrap_look_up(%s): %s\n", BOOTSTRAP_NAME, bootstrap_strerror(kr));
#else
fprintf(stderr, "privileged_startx: bootstrap_look_up(%s): %ul\n", BOOTSTRAP_NAME, (unsigned long)kr);
#endif
exit(EXIT_FAILURE);
}
kr = privileged_startx(mp);
if (kr != KERN_SUCCESS) {
fprintf(stderr, "privileged_startx client: %s\n", mach_error_string(kr));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
CFNetDiagnosticStatus CFNetDiagnosticDiagnoseProblemInteractively(CFNetDiagnosticRef details) {
SInt32 retval = 0;
mach_port_t port = MACH_PORT_NULL;
CFDataRef msgData = NULL;
kern_return_t err;
//build message
CFWriteStreamRef stream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault);
CFWriteStreamOpen(stream);
CFIndex len = CFPropertyListWriteToStream(details, stream, kCFPropertyListBinaryFormat_v1_0, NULL);
CFWriteStreamClose(stream);
if(len > 0) {
msgData = CFWriteStreamCopyProperty(stream, kCFStreamPropertyDataWritten);
}
CFRelease(stream);
if(msgData) {
err = bootstrap_look_up(bootstrap_port, *((name_t*)(&_CFNetDiagnosticMachPortName)), &port);
if (err == KERN_SUCCESS) {
err = _CFNetDiagnosticClient_passDescriptor( port,
_CFNetDiagnosticMachProtocolVersion,
(vm_address_t)CFDataGetBytePtr(msgData),
CFDataGetLength(msgData));
if (err == KERN_SUCCESS) {
//FIXME Yay!!!
}
}
CFRelease(msgData);
}
return (CFNetDiagnosticStatus)retval;
}
CFMessagePortRef CFMessagePortCreateRemote(CFAllocatorRef allocator, CFStringRef name) {
CFMessagePortRef memory;
CFMachPortRef native;
CFMachPortContext ctx;
uint8_t *utfname = NULL;
CFIndex size;
mach_port_t bp, port;
kern_return_t ret;
name = __CFMessagePortSanitizeStringName(allocator, name, &utfname, NULL);
if (NULL == name) {
return NULL;
}
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL != name) {
CFMessagePortRef existing;
if (NULL != __CFAllRemoteMessagePorts && CFDictionaryGetValueIfPresent(__CFAllRemoteMessagePorts, name, (const void **)&existing)) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
CFRelease(name);
CFAllocatorDeallocate(allocator, utfname);
return (CFMessagePortRef)CFRetain(existing);
}
}
size = sizeof(struct __CFMessagePort) - sizeof(CFMessagePortContext) - sizeof(CFRuntimeBase);
memory = (CFMessagePortRef)_CFRuntimeCreateInstance(allocator, __kCFMessagePortTypeID, size, NULL);
if (NULL == memory) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (NULL != name) {
CFRelease(name);
}
CFAllocatorDeallocate(allocator, utfname);
return NULL;
}
__CFMessagePortUnsetValid(memory);
__CFMessagePortSetRemote(memory);
memory->_lock = 0;
memory->_name = name;
memory->_port = NULL;
memory->_replies = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, NULL, NULL);
memory->_convCounter = 0;
memory->_replyPort = NULL;
memory->_source = NULL;
memory->_icallout = NULL;
memory->_callout = NULL;
ctx.version = 0;
ctx.info = memory;
ctx.retain = NULL;
ctx.release = NULL;
ctx.copyDescription = NULL;
task_get_bootstrap_port(mach_task_self(), &bp);
ret = bootstrap_look_up(bp, utfname, &port);
native = (KERN_SUCCESS == ret) ? CFMachPortCreateWithPort(allocator, port, __CFMessagePortDummyCallback, &ctx, NULL) : NULL;
CFAllocatorDeallocate(allocator, utfname);
if (NULL == native) {
__CFSpinUnlock(&__CFAllMessagePortsLock);
// name is released by deallocation
CFRelease(memory);
return NULL;
}
memory->_port = native;
CFMachPortSetInvalidationCallBack(native, __CFMessagePortInvalidationCallBack);
__CFMessagePortSetValid(memory);
if (NULL != name) {
if (NULL == __CFAllRemoteMessagePorts) {
__CFAllRemoteMessagePorts = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
}
CFDictionaryAddValue(__CFAllRemoteMessagePorts, name, memory);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
return (CFMessagePortRef)memory;
}
int main(int argc, char *argv[])
{
char *bname_server = NULL, *bname_client = NULL;
int i, j, ch;
int error;
int num = 1;
int Servers = 1;
int use_kerberos = 0;
int refcnt = 0;
pthread_t thread;
pthread_attr_t attr[1];
char hostbuf[MAXHOSTNAME];
char *host = hostbuf;
char *realm = NULL;
char *ServicePrincipal = NULL;
struct passwd *pent = NULL;
kern_return_t kr;
uid = getuid();
if (seteuid(uid)) {
Log("Could not drop privilege");
exit(EXIT_FAILURE);
}
setprogname(argv[0]);
/* Set up mech table */
mechtab[GSSD_KRB5_MECH] = GSS_KRB5_MECHANISM;
mechtab[GSSD_SPNEGO_MECH] = GSS_SPNEGO_MECHANISM;
mechtab[GSSD_NTLM_MECH] = GSS_NTLM_MECHANISM;
while ((ch = getopt(argc, argv, "b:B:CdDef:hHikN:n:M:m:p:r:Rs:S:t:u:v:V")) != -1) {
switch (ch) {
case 'b':
bname_client = optarg;
break;
case 'B':
bname_server = optarg;
break;
case 'C':
gssd_flags |= GSSD_NO_CANON;
break;
case 'd':
debug++;
break;
case 'D':
gssd_flags |= GSSD_NO_DEFAULT;
break;
case 'e':
exitonerror = 1;
break;
case 'f':
flags |= atoi(optarg);
break;
case 'H':
gssd_flags &= ~GSSD_HOME_ACCESS_OK;
break;
case 'i':
interactive = 1;
break;
case 'k':
use_kerberos = 1;
break;
case 'M':
max_retries = atoi(optarg);
break;
case 'm':
if (strcmp(optarg, "krb5") == 0)
mech = GSSD_KRB5_MECH;
else if (strcmp(optarg, "spnego") == 0)
mech = GSSD_SPNEGO_MECH;
else if (strcmp(optarg, "ntlm") == 0)
mech = GSSD_NTLM_MECH;
else {
Log("Unavailable gss mechanism %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'n':
num = atoi(optarg);
break;
case 'N':
if (strcmp(optarg, "uid") == 0)
name_type = GSSD_MACHINE_UID;
else if (strcmp(optarg, "suid") == 0)
name_type = GSSD_STRING_UID;
else if (strcmp(optarg, "user") == 0)
name_type = GSSD_USER;
else if (strcmp(optarg, "krb5") == 0)
name_type = GSSD_KRB5_PRINCIPAL;
else if (strcmp(optarg, "ntlm") == 0)
name_type = GSSD_NTLM_PRINCIPAL;
else {
Log("Unsupported name type %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'p':
principal = optarg;
break;
case 'r':
realm = optarg;
break;
case 'R':
refcnt = 1;
break;
case 's':
Servers = atoi(optarg);
break;
case 'S':
ServicePrincipal = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'u':
pent = getpwnam(optarg);
if (pent)
uid = pent->pw_uid;
else
Log("Could no find user %s\n", optarg);
break;
case 'V':
verbose++;
break;
case 'v':
version = atoi(optarg);
break;
default:
Usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
gethostname(hostbuf, MAXHOSTNAME);
} else if (argc == 1) {
host = argv[0];
} else {
Usage();
}
if (principal == NULL || *principal == '\0') {
if (pent == NULL)
pent = getpwuid(uid);
principal = pent->pw_name;
name_type = GSSD_USER;
}
clientp.nt = name_type;
switch (name_type) {
case GSSD_USER:
case GSSD_STRING_UID:
case GSSD_KRB5_PRINCIPAL:
case GSSD_NTLM_PRINCIPAL:
clientp.name = (gssd_byte_buffer) principal;
clientp.len = (uint32_t) strlen(principal);
break;
default:
Log("Unsupported name type for principal %s\n", principal);
exit(EXIT_FAILURE);
break;
}
printf("Using creds for %s host=%s\n", principal, host);
if (bname_client) {
kr = bootstrap_look_up(bootstrap_port, bname_client, &client_mp);
if (kr != KERN_SUCCESS) {
Log("bootstrap_look_up(): %s\n", bootstrap_strerror(kr));
exit(EXIT_FAILURE);
}
} else {
client_mp = get_gssd_port();
}
if (!MACH_PORT_VALID(client_mp)) {
Log("Could not get a valid client port (%d)\n", client_mp);
exit(EXIT_FAILURE);
}
if (refcnt)
return do_refcount(mech, name_type, principal);
if (ServicePrincipal)
strlcpy(svcname, ServicePrincipal, sizeof(svcname));
else if (use_kerberos) {
strlcpy(svcname, "nfs/", sizeof(svcname));
strlcat(svcname, host, sizeof(svcname));
if (realm) {
strlcat(svcname, "@", sizeof(svcname));
strlcat(svcname, realm, sizeof(svcname));
}
} else {
strlcpy(svcname, "nfs@", sizeof(svcname));
strlcat(svcname, host, sizeof(svcname));
}
if (!use_kerberos) {
targetp.nt = GSSD_HOSTBASED;
targetp.name = (gssd_byte_buffer)svcname;
targetp.len = (uint32_t) strlen(svcname);
}
printf("Service name = %s\n", svcname);
if (bname_server) {
kr = bootstrap_look_up(bootstrap_port, bname_server, &server_mp);
if (kr != KERN_SUCCESS) {
Log("bootstrap_look_up(): %s\n", bootstrap_strerror(kr));
exit(EXIT_FAILURE);
}
} else {
server_mp = get_gssd_port();
}
if (!MACH_PORT_VALID(server_mp)) {
Log("Could not get a valid server port (%d)\n", server_mp);
exit(EXIT_FAILURE);
}
if (interactive) {
printf("Hit enter to start ");
(void) getchar();
}
pthread_attr_init(attr);
pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED);
pthread_mutex_init(num_servers_lock, NULL);
pthread_cond_init(num_servers_cv, NULL);
for (i = 0; i < num; i++) {
num_servers = Servers;
for (j = 0; j < num_servers; j++) {
error = pthread_create(&thread, attr, server, NULL);
if (error)
Log("Could not start server: %s\n",
strerror(error));
}
waitall();
}
report_errors();
pthread_attr_destroy(attr);
kr = mach_port_deallocate(mach_task_self(), client_mp);
if (kr != KERN_SUCCESS) {
Log("Could not delete send right!\n");
}
kr = mach_port_deallocate(mach_task_self(), server_mp);
if (kr != KERN_SUCCESS) {
Log("Could not delete send right!\n");
}
if (interactive) {
printf("Hit enter to stop\n");
(void) getchar();
}
return (0);
}
int main(int argc, char **argv, char **envp) {
int envpc;
kern_return_t kr;
mach_port_t mp;
string_array_t newenvp;
string_array_t newargv;
size_t i;
int launchd_fd;
string_t handoff_socket_filename;
sig_t handler;
if(argc == 2 && !strcmp(argv[1], "-version")) {
fprintf(stderr, "X.org Release 7.5\n");
fprintf(stderr, "X.Org X Server %s\n", XSERVER_VERSION);
fprintf(stderr, "Build Date: %s\n", BUILD_DATE);
return EXIT_SUCCESS;
}
if(getenv("X11_PREFS_DOMAIN"))
server_bootstrap_name = getenv("X11_PREFS_DOMAIN");
/* We don't have a mechanism in place to handle this interrupt driven
* server-start notification, so just send the signal now, so xinit doesn't
* time out waiting for it and will just poll for the server.
*/
handler = signal(SIGUSR1, SIG_IGN);
if(handler == SIG_IGN)
kill(getppid(), SIGUSR1);
signal(SIGUSR1, handler);
/* Pass on SIGs to X11.app */
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
/* Get the $DISPLAY FD */
launchd_fd = launchd_display_fd();
kr = bootstrap_look_up(bootstrap_port, server_bootstrap_name, &mp);
if(kr != KERN_SUCCESS) {
pid_t child;
fprintf(stderr, "Xquartz: Unable to locate waiting server: %s\n", server_bootstrap_name);
set_x11_path();
/* This forking is ugly and will be cleaned up later */
child = fork();
if(child == -1) {
fprintf(stderr, "Xquartz: Could not fork: %s\n", strerror(errno));
return EXIT_FAILURE;
}
if(child == 0) {
char *_argv[3];
_argv[0] = x11_path;
_argv[1] = "--listenonly";
_argv[2] = NULL;
fprintf(stderr, "Xquartz: Starting X server: %s --listenonly\n", x11_path);
return execvp(x11_path, _argv);
}
/* Try connecting for 10 seconds */
for(i=0; i < 80; i++) {
usleep(250000);
kr = bootstrap_look_up(bootstrap_port, server_bootstrap_name, &mp);
if(kr == KERN_SUCCESS)
break;
}
if(kr != KERN_SUCCESS) {
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
fprintf(stderr, "Xquartz: bootstrap_look_up(): %s\n", bootstrap_strerror(kr));
#else
fprintf(stderr, "Xquartz: bootstrap_look_up(): %ul\n", (unsigned long)kr);
#endif
return EXIT_FAILURE;
}
}
/* Get X11.app's pid */
request_pid(mp, &x11app_pid);
/* Handoff the $DISPLAY FD */
if(launchd_fd != -1) {
size_t try, try_max;
int handoff_fd = -1;
for(try=0, try_max=5; try < try_max; try++) {
if(request_fd_handoff_socket(mp, handoff_socket_filename) != KERN_SUCCESS) {
fprintf(stderr, "Xquartz: Failed to request a socket from the server to send the $DISPLAY fd over (try %d of %d)\n", (int)try+1, (int)try_max);
continue;
}
handoff_fd = connect_to_socket(handoff_socket_filename);
if(handoff_fd == -1) {
fprintf(stderr, "Xquartz: Failed to connect to socket (try %d of %d)\n", (int)try+1, (int)try_max);
continue;
}
#ifdef DEBUG
fprintf(stderr, "Xquartz: Handoff connection established (try %d of %d) on fd %d, \"%s\". Sending message.\n", (int)try+1, (int)try_max, handoff_fd, handoff_socket_filename);
#endif
send_fd_handoff(handoff_fd, launchd_fd);
close(handoff_fd);
break;
}
}
/* Count envp */
for(envpc=0; envp[envpc]; envpc++);
/* We have fixed-size string lengths due to limitations in IPC,
* so we need to copy our argv and envp.
*/
newargv = (string_array_t)malloc(argc * sizeof(string_t));
newenvp = (string_array_t)malloc(envpc * sizeof(string_t));
if(!newargv || !newenvp) {
fprintf(stderr, "Xquartz: Memory allocation failure\n");
return EXIT_FAILURE;
}
for(i=0; i < argc; i++) {
strlcpy(newargv[i], argv[i], STRING_T_SIZE);
}
for(i=0; i < envpc; i++) {
strlcpy(newenvp[i], envp[i], STRING_T_SIZE);
}
kr = start_x11_server(mp, newargv, argc, newenvp, envpc);
free(newargv);
free(newenvp);
if (kr != KERN_SUCCESS) {
fprintf(stderr, "Xquartz: start_x11_server: %s\n", mach_error_string(kr));
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static int startup_trigger(int argc, char **argv, char **envp) {
Display *display;
const char *s;
/* Take care of the case where we're called like a normal DDX */
if(argc > 1 && argv[1][0] == ':') {
size_t i;
kern_return_t kr;
mach_port_t mp;
string_array_t newenvp;
string_array_t newargv;
/* We need to count envp */
int envpc;
for(envpc=0; envp[envpc]; envpc++);
/* We have fixed-size string lengths due to limitations in IPC,
* so we need to copy our argv and envp.
*/
newargv = (string_array_t)alloca(argc * sizeof(string_t));
newenvp = (string_array_t)alloca(envpc * sizeof(string_t));
if(!newargv || !newenvp) {
fprintf(stderr, "Memory allocation failure\n");
exit(EXIT_FAILURE);
}
for(i=0; i < argc; i++) {
strlcpy(newargv[i], argv[i], STRING_T_SIZE);
}
for(i=0; i < envpc; i++) {
strlcpy(newenvp[i], envp[i], STRING_T_SIZE);
}
kr = bootstrap_look_up(bootstrap_port, server_bootstrap_name, &mp);
if (kr != KERN_SUCCESS) {
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
fprintf(stderr, "bootstrap_look_up(%s): %s\n", server_bootstrap_name, bootstrap_strerror(kr));
#else
fprintf(stderr, "bootstrap_look_up(%s): %ul\n", server_bootstrap_name, (unsigned long)kr);
#endif
exit(EXIT_FAILURE);
}
kr = start_x11_server(mp, newargv, argc, newenvp, envpc);
if (kr != KERN_SUCCESS) {
fprintf(stderr, "start_x11_server: %s\n", mach_error_string(kr));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
/* If we have a process serial number and it's our only arg, act as if
* the user double clicked the app bundle: launch app_to_run if possible
*/
if(argc == 1 || (argc == 2 && !strncmp(argv[1], "-psn_", 5))) {
/* Now, try to open a display, if so, run the launcher */
display = XOpenDisplay(NULL);
if(display) {
/* Could open the display, start the launcher */
XCloseDisplay(display);
return execute(command_from_prefs("app_to_run", DEFAULT_CLIENT));
}
}
/* Start the server */
if((s = getenv("DISPLAY"))) {
fprintf(stderr, "X11.app: Could not connect to server (DISPLAY=\"%s\", unsetting). Starting X server.\n", s);
unsetenv("DISPLAY");
} else {
fprintf(stderr, "X11.app: Could not connect to server (DISPLAY is not set). Starting X server.\n");
}
return execute(command_from_prefs("startx_script", DEFAULT_STARTX));
}
/*ARGSUSED*/
int
benchmark_initbatch(void *tsd)
{
/*
* initialize your state variables here second
*/
long pid;
tsd_t *ts = (tsd_t *)tsd;
ts->server_mode = -1;
ts->verbose = opt_verbose;
ts->oneway = opt_oneway;
ts->overwrite = 0;
ts->msg_type = opt_msg_type;
ts->num_ints = opt_num_ints;
ts->num_msgs = opt_num_msgs;
ts->server_port_name = opt_server_port_name;
ts->server_port = MACH_PORT_NULL;
ts->reply_port = MACH_PORT_NULL;
ts->request_msg = NULL;
ts->request_msg_size = 0;
ts->reply_msg = NULL;
ts->reply_msg_size = 0;
switch (ts->msg_type) {
case msg_type_trivial:
ts->request_msg_size = sizeof(ipc_trivial_message);
break;
case msg_type_inline:
ts->request_msg_size = sizeof(ipc_inline_message) +
sizeof(u_int32_t) * ts->num_ints;
break;
case msg_type_complex:
ts->request_msg_size = sizeof(ipc_complex_message);
ts->ints = malloc(sizeof(u_int32_t) * ts->num_ints);
break;
}
ts->request_msg = malloc(ts->request_msg_size);
ts->reply_msg = malloc(ts->reply_msg_size);
if (ts->server_mode) {
kern_return_t ret = 0;
mach_port_t bsport;
ts->reply_msg_size -= sizeof(mach_msg_trailer_t);
ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE,
&(ts->server_port));
if (KERN_SUCCESS != ret) {
mach_error("mach_port_allocate(): ", ret);
exit(1);
}
ret = mach_port_insert_right(mach_task_self(), ts->server_port,
ts->server_port, MACH_MSG_TYPE_MAKE_SEND);
if (KERN_SUCCESS != ret) {
mach_error("mach_port_insert_right(): ", ret);
exit(1);
}
ret = task_get_bootstrap_port(mach_task_self(), &bsport);
if (KERN_SUCCESS != ret) {
mach_error("task_get_bootstrap_port(): ", ret);
exit(1);
}
ret = bootstrap_check_in(bsport, (char *)ts->server_port_name,
&ts->server_port);
if (KERN_SUCCESS != ret) {
mach_error("bootstrap_register(): ", ret);
exit(1);
}
} else { /* client mode */
kern_return_t ret = 0;
mach_port_t bsport;
ts->request_msg_size -= sizeof(mach_msg_trailer_t);
ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE,
&(ts->reply_port));
if (KERN_SUCCESS != ret) {
mach_error("mach_port_allocate(): ", ret);
exit(1);
}
ret = task_get_bootstrap_port(mach_task_self(), &bsport);
if (KERN_SUCCESS != ret) {
mach_error("task_get_bootstrap_port(): ", ret);
exit(1);
}
ret = bootstrap_look_up(bsport, (char *)ts->server_port_name,
&(ts->server_port));
if (KERN_SUCCESS != ret) {
mach_error("bootstrap_look_up(): ", ret);
exit(1);
}
}
if (ts->verbose) {
if (ts->server_mode) {
printf("Server waiting for IPC messages from client on port '%s'.\n",
ts->server_port_name);
} else {
printf("Client sending %d %s IPC messages to port '%s' in %s mode.\n",
ts->num_msgs, (ts->msg_type == msg_type_inline) ? "inline" :
((ts->msg_type == msg_type_complex) ? "complex" : "trivial"),
ts->server_port_name, (ts->oneway ? "oneway" : "rpc"));
}
}
pid = fork();
switch (pid) {
case 0:
server(tsd);
exit(0);
break;
case -1:
return (-1);
default:
ts->pid = pid;
break;
}
return (0);
}
int
main(int argc, char **argv)
{
kern_return_t kr;
msg_format_recv_t recv_msg;
msg_format_send_t send_msg;
mach_msg_header_t *recv_hdr, *send_hdr;
mach_port_t client_port, server_port;
kr = bootstrap_look_up(bootstrap_port, SERVICE_NAME, &server_port);
EXIT_ON_MACH_ERROR("bootstrap_look_up", kr, BOOTSTRAP_SUCCESS);
kr = mach_port_allocate(mach_task_self(), // our task is acquiring
MACH_PORT_RIGHT_RECEIVE, // a new receive right
&client_port); // with this name
EXIT_ON_MACH_ERROR("mach_port_allocate", kr, KERN_SUCCESS);
printf("client_port = %d, server_port = %d\n", client_port, server_port);
// prepare request
send_hdr = &(send_msg.header);
send_hdr->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, \
MACH_MSG_TYPE_MAKE_SEND);
send_hdr->msgh_size = sizeof(send_msg);
send_hdr->msgh_remote_port = server_port;
send_hdr->msgh_local_port = client_port;
send_hdr->msgh_reserved = 0;
send_hdr->msgh_id = DEFAULT_MSG_ID;
send_msg.data = 0;
if (argc == 2)
send_msg.data = atoi(argv[1]);
if ((send_msg.data < 1) || (send_msg.data > 20))
send_msg.data = 1; // some sane default value
// send request
kr = mach_msg(send_hdr, // message buffer
MACH_SEND_MSG, // option indicating send
send_hdr->msgh_size, // size of header + body
0, // receive limit
MACH_PORT_NULL, // receive name
MACH_MSG_TIMEOUT_NONE, // no timeout, wait forever
MACH_PORT_NULL); // no notification port
EXIT_ON_MACH_ERROR("mach_msg(send)", kr, MACH_MSG_SUCCESS);
do { // receive reply
recv_hdr = &(recv_msg.header);
recv_hdr->msgh_remote_port = server_port;
recv_hdr->msgh_local_port = client_port;
recv_hdr->msgh_size = sizeof(recv_msg);
kr = mach_msg(recv_hdr, // message buffer
MACH_RCV_MSG, // option indicating receive
0, // send size
recv_hdr->msgh_size, // size of header + body
client_port, // receive name
MACH_MSG_TIMEOUT_NONE, // no timeout, wait forever
MACH_PORT_NULL); // no notification port
EXIT_ON_MACH_ERROR("mach_msg(recv)", kr, MACH_MSG_SUCCESS);
printf("%d\n", recv_msg.data);
} while (recv_hdr->msgh_id != DEFAULT_MSG_ID);
exit(0);
}
int
main(int argc, char **argv)
{
extern int optind;
extern char *optarg;
#ifdef __OPENSTEP__
extern int getopt(int argc, char **argv, char *optstring);
#endif
int c;
int bflag = 0, hflag = 0, pflag = 0, eflag = 0, dflag = 0;
int sflag = 0;
int errflag = 0;
char *ofile = "gmon.out";
char *dylib;
port_t server_port;
port_t control_port;
enum profile_state state;
enum request_type request = -1, control_request = -1;
char gmon_file[MAXPATHLEN];
boolean_t profile_active, control_active;
enum result_code result;
kern_return_t ret;
progname = argv[0];
if (argc == 1) {
usage();
exit(2);
}
while ((c = getopt(argc, argv, "crbhpo:eds")) != EOF)
switch (c) {
case 'c':
request = NSCreateProfileBufferForLibrary;
break;
case 'r':
request = NSRemoveProfileBufferForLibrary;
break;
case 'b':
bflag = 1;
request = NSStartProfilingForLibrary;
break;
case 'h':
hflag = 1;
request = NSStopProfilingForLibrary;
break;
case 'p':
request = NSBufferFileForLibrary,
pflag = 1;
break;
case 'o':
ofile = optarg;
break;
case 'e':
eflag = 1;
control_request = NSEnableProfiling;
break;
case 'd':
dflag = 1;
control_request = NSDisableProfiling;
break;
case 's':
sflag = 1;
break;
default:
errflag = 1;
break;
}
if (dflag && eflag) {
fprintf(stderr, "You must specify only one of -d and -e.\n");
usage();
exit(2);
}
if (bflag && hflag) {
fprintf(stderr, "You must specify only one of -b and -h.\n");
usage();
exit(2);
}
if (errflag || (!(dflag || eflag || sflag) && optind >= argc)) {
usage();
exit(2);
}
dylib = argv[optind];
if (bootstrap_look_up(bootstrap_port, PROFILE_SERVER_NAME, &server_port)
!= BOOTSTRAP_SUCCESS ||
bootstrap_status(bootstrap_port, PROFILE_SERVER_NAME, &profile_active)
!= BOOTSTRAP_SUCCESS) {
fprintf(stderr, "%s: couldn't locate profile server port\n",progname);
exit(3);
}
if (bootstrap_look_up(bootstrap_port, PROFILE_CONTROL_NAME, &control_port)
!= BOOTSTRAP_SUCCESS ||
bootstrap_status(bootstrap_port, PROFILE_CONTROL_NAME, &control_active)
!= BOOTSTRAP_SUCCESS) {
fprintf(stderr, "%s: couldn't locate profile control port\n",progname);
exit(3);
}
if (sflag) {
if (!control_active) {
printf("Profiling service not found\n");
exit(0);
}
if (!profile_active) {
printf("Profiling service not enabled\n");
exit(0);
}
print_status(server_port);
exit(0);
}
*gmon_file = '\0';
if (dflag || eflag) {
if (!control_active) {
fprintf(stderr, "%s: profile server isn't running\n", progname);
exit(3);
}
if ((ret = send_request(control_port, control_request, "", &state, &result, gmon_file)) != KERN_SUCCESS) {
fprintf(stderr, "%s: msg_send failed: %s", progname, mach_error_string(ret));
exit(3);
}
if (result != NSSuccess) {
profile_error(control_request, dylib, result);
exit(3);
}
exit(0);
}
if (request != -1) {
if (!profile_active) {
fprintf(stderr, "%s: profile server isn't active.\n", progname);
fprintf(stderr, "Use '%s -e' to enable it.\n", progname);
exit(3);
}
if ((ret = send_request(server_port, request, dylib, &state, &result, gmon_file)) != KERN_SUCCESS) {
fprintf(stderr, "%s: msg_send failed: %s\n", progname, mach_error_string(ret));
exit(3);
}
if (result != NSSuccess) {
profile_error(request, dylib, result);
exit(3);
}
}
if (pflag) {
if (*gmon_file == '\0' || state == NSBufferNotCreated) {
fprintf(stderr, "%s: dylib %s not found\n",progname,dylib);
exit(1);
}
errflag = copy_file(gmon_file, ofile);
if (errflag) {
fprintf(stderr,"%s: couldn't write to %s\n", progname, ofile);
exit(errflag);
}
}
exit(0);
}
void *client(void *threadarg)
{
struct port_args args;
struct port_args *svr_args = NULL;
int idx;
mach_msg_header_t *req, *reply;
mach_port_t bsport, servport;
kern_return_t ret;
int server_num = (int)(uintptr_t)threadarg;
void *ints = malloc(sizeof(u_int32_t) * num_ints);
if (verbose)
printf("client(%d) started, server port name %s\n",
server_num, server_port_name[server_num]);
args.server_num = server_num;
thread_setup(server_num + 1);
if (stress_prepost)
svr_args = &server_port_args[server_num];
/* find server port */
ret = task_get_bootstrap_port(mach_task_self(), &bsport);
if (KERN_SUCCESS != ret) {
mach_error("task_get_bootstrap_port(): ", ret);
exit(1);
}
ret = bootstrap_look_up(bsport,
server_port_name[server_num],
&servport);
if (KERN_SUCCESS != ret) {
mach_error("bootstrap_look_up(): ", ret);
exit(1);
}
setup_client_ports(&args);
/* Allocate and touch memory */
if (client_pages) {
unsigned i;
client_memory = (long *) malloc(client_pages * PAGE_SIZE);
for (i = 0; i < client_pages; i++)
client_memory[i * PAGE_SIZE / sizeof(long)] = 0;
}
uint64_t starttm, endtm;
/* start message loop */
for (idx = 0; idx < num_msgs; idx++) {
req = args.req_msg;
reply = args.reply_msg;
req->msgh_size = args.req_size;
if (stress_prepost) {
req->msgh_remote_port = svr_args->port_list[idx % portcount];
} else {
req->msgh_remote_port = servport;
}
if (oneway) {
req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
req->msgh_local_port = MACH_PORT_NULL;
} else {
req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
MACH_MSG_TYPE_MAKE_SEND_ONCE);
req->msgh_local_port = args.port;
}
req->msgh_id = oneway ? 0 : 1;
if (msg_type == msg_type_complex) {
(req)->msgh_bits |= MACH_MSGH_BITS_COMPLEX;
((ipc_complex_message *)req)->body.msgh_descriptor_count = 1;
((ipc_complex_message *)req)->descriptor.address = ints;
((ipc_complex_message *)req)->descriptor.size =
num_ints * sizeof(u_int32_t);
((ipc_complex_message *)req)->descriptor.deallocate = FALSE;
((ipc_complex_message *)req)->descriptor.copy = MACH_MSG_VIRTUAL_COPY;
((ipc_complex_message *)req)->descriptor.type = MACH_MSG_OOL_DESCRIPTOR;
}
if (verbose > 2)
printf("client sending message %d to port %#x\n",
idx, req->msgh_remote_port);
starttm = mach_absolute_time();
ret = mach_msg(req,
MACH_SEND_MSG,
args.req_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
endtm = mach_absolute_time();
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (send): ", ret);
fprintf(stderr, "bailing after %u iterations\n", idx);
exit(1);
break;
}
if (stress_prepost)
OSAtomicAdd64(endtm - starttm, &g_client_send_time);
if (!oneway) {
if (verbose > 2)
printf("client awaiting reply %d\n", idx);
reply->msgh_bits = 0;
reply->msgh_size = args.reply_size;
reply->msgh_local_port = args.port;
ret = mach_msg(args.reply_msg,
MACH_RCV_MSG|MACH_RCV_INTERRUPT,
0,
args.reply_size,
args.port,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (MACH_MSG_SUCCESS != ret) {
mach_error("mach_msg (receive): ", ret);
fprintf(stderr, "bailing after %u iterations\n",
idx);
exit(1);
}
if (verbose > 2)
printf("client received reply %d\n", idx);
}
client_work();
}
free(ints);
return NULL;
}
static kern_return_t k5_ipc_client_lookup_server (const char *in_service_id,
boolean_t in_launch_if_necessary,
boolean_t in_use_cached_port,
mach_port_t *out_service_port)
{
kern_return_t err = 0;
kern_return_t lock_err = 0;
mach_port_t k5_service_port = MACH_PORT_NULL;
boolean_t found_entry = 0;
int i;
if (!in_service_id ) { err = EINVAL; }
if (!out_service_port) { err = EINVAL; }
if (!err) {
lock_err = k5_mutex_lock (&g_service_ports_mutex);
if (lock_err) { err = lock_err; }
}
for (i = 0; !err && i < KIPC_SERVICE_COUNT; i++) {
if (!strcmp (in_service_id, g_service_ports[i].service_id)) {
found_entry = 1;
if (in_use_cached_port) {
k5_service_port = g_service_ports[i].service_port;
}
break;
}
}
if (!err && (!MACH_PORT_VALID (k5_service_port) || !in_use_cached_port)) {
mach_port_t boot_port = MACH_PORT_NULL;
char *service = NULL;
/* Get our bootstrap port */
err = task_get_bootstrap_port (mach_task_self (), &boot_port);
if (!err && !in_launch_if_necessary) {
char *lookup = NULL;
mach_port_t lookup_port = MACH_PORT_NULL;
int w = asprintf (&lookup, "%s%s",
in_service_id, K5_MIG_LOOKUP_SUFFIX);
if (w < 0) { err = ENOMEM; }
if (!err) {
/* Use the lookup name because the service name will return
* a valid port even if the server isn't running */
err = bootstrap_look_up (boot_port, lookup, &lookup_port);
}
free (lookup);
if (MACH_PORT_VALID (lookup_port)) {
mach_port_deallocate (mach_task_self (), lookup_port);
}
}
if (!err) {
int w = asprintf (&service, "%s%s",
in_service_id, K5_MIG_SERVICE_SUFFIX);
if (w < 0) { err = ENOMEM; }
}
if (!err) {
err = bootstrap_look_up (boot_port, service, &k5_service_port);
if (!err && found_entry) {
/* Free old port if it is valid */
if (!err && MACH_PORT_VALID (g_service_ports[i].service_port)) {
mach_port_deallocate (mach_task_self (),
g_service_ports[i].service_port);
}
g_service_ports[i].service_port = k5_service_port;
}
}
free (service);
if (MACH_PORT_VALID (boot_port)) { mach_port_deallocate (mach_task_self (),
boot_port); }
}
if (!err) {
*out_service_port = k5_service_port;
}
if (!lock_err) { k5_mutex_unlock (&g_service_ports_mutex); }
return err;
}
