• Article Delegate/2849 (95nov28 Www Clients For Mac Free
• Article Delegate/2849 (95nov28 Www Clients For Mac Download

I think MSFT updated the article couple of days ago, because today it says: •A boss (delegator) can have 25 administrators (delegates). •An administrator (delegate) can have up to 25 bosses (delegators). Skype for Business 2016 MSI clients are still limited to 2 bosses per delegate. Same issue, that happens to us when sending an email with delegate permissions from another recipient/mailbox Thursday, December 7, 2017 10:35 AM Reply.

Important: This article describes ways to make socket connections that are completely under the control of your program. Most programs would be better served by higher-level APIs such as NSURLConnection.

To learn more about these higher-level APIs, read. The APIs described in this article should be used only if you need to support some protocol other than the protocols supported by built-in Cocoa or Core Foundation functionality. At almost every level of networking, software can be divided into two categories: clients (programs that connect to other apps) and services (programs that other apps connect to).

At a high level, these lines are clear. Most programs written using high-level APIs are purely clients. At a lower level, however, the lines are often blurry. Socket and stream programming generally falls into one of the following broad categories:. Packet-based communication—Programs that operate on one packet at a time, listening for incoming packets, then sending packets in reply.

With packet-based communication, the only differences between clients and servers are the contents of the packets that each program sends and receives, and (presumably) what each program does with the data. The networking code itself is identical. Stream-based clients—Programs that use TCP to send and receive data as two continuous streams of bytes, one in each direction. With stream-based communication, clients and servers are somewhat more distinct.

The actual data handling part of clients and servers is similar, but the way that the program initially constructs the communication channel is very different. This chapter is divided into sections based on the above tasks:. —Describes how to decide which API family to use when writing networking code.

—Describes how to make outgoing TCP connections to existing servers and services. —Describes how to listen for incoming TCP connections when writing servers and services. —Describes how to work with non-TCP protocols, such as UDP. Choosing an API Family The API you choose for socket-based connections depends on whether you are making a connection to another host or receiving a connection from another host.

It also depends on whether you are using TCP or some other protocol. Here are a few factors to consider:. In OS X, if you already have networking code that is shared with non-Apple platforms, you can use POSIX C networking APIs and continue to use your networking code as-is (on a separate thread).

If your program is based on a Core Foundation or Cocoa (Foundation) run loop, you can also use the Core Foundation CFStream API to integrate the POSIX networking code into your overall architecture on the main thread. Alternatively, if you are using Grand Central Dispatch (GCD), you can add a socket as a dispatch source. In iOS, POSIX networking is discouraged because it does not activate the cellular radio or on-demand VPN. Thus, as a general rule, you should separate the networking code from any common data processing functionality and rewrite the networking code using higher-level APIs. Note: If you use POSIX networking code, you should be aware that the POSIX networking API is not protocol-agnostic (you must handle some of the differences between IPv4 and IPv6 yourself). It is a connect-by-IP API rather than a connect-by-name API, which means that you must do a lot of extra work if you want to achieve the same initial-connection performance and robustness that higher-level APIs give you for free. Before you decide to reuse existing POSIX networking code, be sure to read in.

For daemons and services that listen on a port, or for non-TCP connections, use POSIX or Core Foundation ( CFSocket) C networking APIs. For client code in Objective-C, use Foundation Objective-C networking APIs. Foundation defines high-level classes for managing URL connections, socket streams, network services, and other networking tasks. It is also the primary non-UI Objective-C framework in OS X and iOS, providing routines for run loops, string handling, collection objects, file access, and so on.

For client code in C, use Core Foundation C networking APIs. The Core Foundation framework and the CFNetwork framework are two of the primary C-language frameworks in OS X and iOS. Together they define the functions and structures upon which the Foundation networking classes are built. Note: In OS X, CFNetwork is a subframework of the Core Services framework; in iOS, CFNetwork is a top-level framework. Writing a TCP-Based Client The way you make an outgoing connection depends on what programming language you are using, on the type of connection (TCP, UDP, and so forth), and on whether you are trying to share code with other (non-Mac, non-iOS) platforms.

Use NSStream for outgoing connections in Objective-C. If you are connecting to a specific host, create a CFHost object ( not NSHost—they are not toll-free bridged), then use or to open a socket connected to that host and port and associate a pair of CFStream objects with it.

You can then cast these to an NSStream object. You can also use the function with a object to connect to a Bonjour service. Read in for more information. Note: The getStreamsToHost:port:inputStream:outputStream: method of is not available on iOS, and is discouraged on OS X for performance reasons. Specifically, NSNetService requires you to create an instance of NSHost.

When you create the object, the lookup is performed synchronously. Thus, it is unsafe to construct an NSHost object on your main application thread. See for details.

Use CFStream for outgoing connections in C. If you are writing code that cannot include Objective-C, use the CFStream API.

It integrates more easily with other Core Foundation APIs than CFSocket, and enables the cellular hardware on iOS (where applicable), unlike lower-level APIs. You can use or to open a socket connected to a given host and port and associate a pair of CFStream objects with it. You can also use the function to connect to a Bonjour service. Read in for more information. Use POSIX calls if cross-platform portability is required. If you are writing networking code that runs exclusively in OS X and iOS, you should generally avoid POSIX networking calls, because they are harder to work with than higher-level APIs.

However, if you are writing networking code that must be shared with other platforms, you can use the POSIX networking APIs so that you can use the same code everywhere. Never use synchronous POSIX networking APIs on the main thread of a GUI application. If you use synchronous networking calls in a GUI application, you must do so on a separate thread. Note: POSIX networking does not activate the cellular radio on iOS. For this reason, the POSIX networking API is generally discouraged in iOS.

The subsections below describe the use of NSStream. Except where noted, the CFStream API has functions with similar names, and behaves similarly. To learn more about the POSIX socket API, read the UNIX Socket FAQ at. Establishing a Connection As a rule, the recommended way to establish a TCP connection to a remote host is with streams. Streams automatically handle many of the challenges that TCP connections present.

For example, streams provide the ability to connect by hostname, and in iOS, they automatically activate a device’s cellular modem or on-demand VPN when needed (unlike CFSocket or BSD sockets). Streams are also a more Cocoa-like networking interface than lower-level protocols, behaving in a way that is largely compatible with the Cocoa file stream APIs. The way you obtain input and output streams for a host depends on whether you used service discovery to discover the host:. If you already know the DNS name or IP address of the remote host, obtain Core Foundation read (input) and write (output) streams with the function. You can then take advantage of the toll-free bridge between CFStream and NSStream to cast your and objects to and objects. If you discovered the host by browsing for network services with a CFNetServiceBrowser object, you obtain input and output streams for the service with the function.

Read in for more information. After you have obtained your input and output streams, you should retain them immediately if you are not using automatic reference counting. Then cast them to NSInputStream and NSOutputStream objects, set their delegate objects (which should conform to the protocol), schedule them on the current run loop, and call their methods. Note: If you are working with more than one connection at a time, you must also keep track of which input stream is associated with a given output stream and vice versa. The most straightforward way to do this is to create your own connection object that holds references to both streams, and then set that object as the delegate for each stream. Handling Events When the method is called on the NSOutputStream object’s delegate and the streamEvent parameter’s value is, call to send data.

This method returns the number of bytes written or a negative number on error. If fewer bytes were written than you tried to send, you must queue up the remaining data and send it after the delegate method gets called again with an NSStreamEventHasSpaceAvailable event.

If an error occurs, you should call to find out what went wrong. When the method is called on your NSInputStream object’s delegate and the streamEvent parameter’s value is, your input stream has received data that you can read with the method. This method returns the number of bytes read, or a negative number on error.

If fewer bytes were read than you need, you must queue the data and wait until you receive another stream event with additional data. If an error occurs, you should call to find out what went wrong.

If the other end of the connection closes the connection:. Your connection delegate’s stream:handleEvent: method is called with streamEvent set to NSStreamEventHasBytesAvailable.

When you read from that stream, you get a length of zero ( 0). Your connection delegate’s stream:handleEvent: method is called with streamEvent set to. When either of these two events occurs, the delegate method is responsible for detecting the end-of-file condition and cleaning up. Closing the Connection To close your connection, unschedule it from the run loop, set the connection’s delegate to nil (the delegate is unretained), close both of the associated streams with the method, and then release the streams themselves (if you are not using ARC) or set them to nil (if you are). By default, this closes the underlying socket connection. There are two situations in which you must close it yourself, however:.

If you previously set the to kCFBooleanFalse by calling on the stream. If you created the streams based on an existing BSD socket by calling.

By default, streams created from an existing native socket do not close their underlying socket. However, you can enable automatic closing by setting the to kCFBooleanTrue with the method. For More Information To learn more, read in, or see the and sample code projects. Writing a TCP-Based Server As mentioned previously, a server and a client are similar once the connection is established. The main difference is that clients make outgoing connections, whereas servers create a listening socket (sometimes listen socket)—a socket that listens for incoming connections—then accept connections on that socket.

After that, each resulting connection behaves just like a connection you might make in a client. The API you should choose for your server depends primarily on whether you are trying to share the code with other (non-Mac, non-iOS) platforms.

There are only two APIs that provide the ability to listen for incoming network connections: the Core Foundation socket API and the POSIX (BSD) socket API. Higher-level APIs cannot be used for accepting incoming connections. If you are writing code for OS X and iOS exclusively, use POSIX networking calls to set up your network sockets. Then, use GCD or CFSocket to integrate the sockets into your run loop. Use pure POSIX networking code with a POSIX-based run loop ( ) if cross-platform portability with non-Apple platforms is required. If you are writing networking code that runs exclusively in OS X and iOS, you should generally avoid POSIX networking calls because they are harder to work with than higher level APIs.

However, if you are writing networking code that must be shared with other platforms, you can use the POSIX networking APIs so that you can use the same code everywhere. Never use NSSocketPort or NSFileHandle for general socket communication.

For details, see in. The following sections describe how to use these APIs to listen for incoming connections. Listening with Core Foundation To use Core Foundation APIs to listen for incoming connections, you must do the following:. Add appropriate includes. CFRunLoopSourceRef socketsource = CFSocketCreateRunLoopSource( kCFAllocatorDefault, myipv4cfsock, 0); CFRunLoopAddSource( CFRunLoopGetCurrent, socketsource, kCFRunLoopDefaultMode); CFRunLoopSourceRef socketsource6 = CFSocketCreateRunLoopSource( kCFAllocatorDefault, myipv6cfsock, 0); CFRunLoopAddSource( CFRunLoopGetCurrent, socketsource6, kCFRunLoopDefaultMode); After this, you can access the underlying BSD socket descriptor with the function. When you are through with the socket, you must close it by calling. In your listening socket’s callback function ( handleConnect in this case), you should check to make sure the value of the callbackType parameter is, which means that a new connection has been accepted.

In this case, the data parameter of the callback is a pointer to a value (an integer socket number) representing the socket. To handle the new incoming connections, you can use the CFStream, NSStream, or CFSocket APIs. The stream-based APIs are strongly recommended. To do this:. Create read and write streams for the socket with the function. Cast the streams to an NSInputStream object and an NSOutputStream object if you are working in Cocoa. Use the streams as described in.

For more information, see. For sample code, see the and sample code projects. Listening with POSIX Socket APIs POSIX networking is fairly similar to the CFSocket API, except that you have to write your own run-loop-handling code.

Struct timeval tv; tv.tvsec = 1; /. 1 second timeout./ tv.tvusec = 0; /. no microseconds./ It is important to choose a timeout that is reasonable. Short timeout values bog down the system by causing your process to run more frequently than is necessary. Unless you are doing something very unusual, your select loop should not wake more than a few times per second, at most, and on iOS, you should try to avoid doing this at all. For alternatives, read in.

If you do not need to perform periodic actions, pass NULL. Call select in a loop, passing two separate copies of that file descriptor set (created by calling FDCOPY) for the read and write descriptor sets. The select system call modifies these descriptor sets, clearing any descriptors that are not ready for reading or writing. For the timeout parameter, pass the timeval structure you created earlier. Although OS X and iOS do not modify this structure, some other operating systems replace this value with the amount of time remaining.

Thus, for cross-platform compatibility, you must reset this value each time you call select. For the nfds parameter, pass a number that is one higher than the highest-numbered file descriptor that is actually in use. Read data from sockets, calling FDISSET to determine if a given socket has pending data.

Write data to calling FDISSET to determine if a given socket has room for new data. Maintain appropriate queues for incoming and outgoing data. As an alternative to the POSIX function, the BSD-specific API can also be used to handle socket events.

For More Information To learn more about POSIX networking, read the, and manual pages. Working with Packet-Based Sockets The recommended way to send and receive UDP packets is by combining the POSIX API and either the CFSocket or GCD APIs. To use these APIs, you must perform the following steps:.

Create a socket by calling. Bind the socket by calling. Provide a sockaddr struct that specifies information about the desired port and family. Connect the socket by calling (optional).

Note that a connected UDP socket is not a connection in the purest sense of the word. However, it provides two advantages over an unconnected socket. First, it removes the need to specify the destination address every time you send a new message. Second, your app may receive errors when a packet cannot be delivered. This error delivery is not guaranteed with UDP, however; it is dependent on network conditions that are beyond your app’s control.

From there, you can work with the connection in three ways:. If you are using GCD for run loop integration (recommended), create a dispatch source by calling dispatchsourcecreate.

Assign an event handler to the dispatch source. Optionally assign a cancellation handler.

Finally, pass the dispatch source to the dispatchresume function to begin handling events. If you are using CFSocket for integration, this technique is somewhat more complicated, but makes it easier to interface your code with some Cocoa APIs.

However, CFSocket objects use a single object to represent a connection (much like sockets at the POSIX layer), whereas most Cocoa APIs are designed to interface with stream-based APIs that use separate objects for sending and receiving. As a result, some Cocoa APIs that expect read or write streams may be difficult to use in conjunction with CFSocketRef objects. To use CFSocket:. Create an object to use for managing the connection. If you are writing Objective-C code, this can be a class. If you are writing pure C code, this should be a Core Foundation object, such as a mutable dictionary.

Create a context object to describe that object. CFRunLoopSourceRef socketsource = CFSocketCreateRunLoopSource( kCFAllocatorDefault, connection, 0); CFRunLoopAddSource(CFRunLoopGetCurrent, socketsource, kCFRunLoopDefaultMode); Whenever new data becomes available, the data handler callback gets called. In your callback, if the value of the callbackType parameter is, check the data parameter passed into the callback. If it is NULL, you have connected to the host. You can then send data using the function. When you are finished with the socket, close and invalidate it by calling the function. At any point, you can also access the underlying BSD socket by calling the function.

Article Delegate/2849 (95nov28 Www Clients For Mac Free

For more information, see. For sample code, see the sample code project. If you are using pure POSIX sockets, use the system call to wait for data, then use the and system calls to perform I/O. To learn more about sending and receiving UDP packets with the POSIX socket API, read the UNIX Socket FAQ at. Obtaining the Native Socket Handle for a Socket Stream Sometimes when working with socket-based streams ( NSInputStream, NSOutputStream, CFReadStream, or CFWriteStream), you may need to obtain the underlying socket handle associated with a stream. For example, you might want to find out the IP address and port number for each end of the stream with and, or set socket options with. To obtain the native socket handle for an input stream, call the following method.

Topic Last Modified: 2017-05-03 Summary: Skype for Business Server 2015 or Skype for Business Online administrators can use these tables to understand what features are supported on which clients. Before you deploy or upgrade to Skype for Business, check which clients are already in use in your organization. Use the tables below to understand the feature support impact on those clients. This can help you communicate changes to users, pace the roll-out process, and fully understand the benefits of upgrading to the latest client.

Some features available with Skype for Business Server 2015 are not available in Skype for Business Online, see for specifics. Skype for Business Online Admins may want to refer to for information on the different plans available to them. The following tables show the features that are available with each client that works with Skype for Business Server 2015 or Skype for Business Online.

You may also want to refer to. The Client Access License or User Subscription License your organization purchases will also have an impact on which features are available to your users. Whether you deploy the Full or Basic client to users depends on the license or plan your organization chooses to buy. See the for more details. Important: Skype for Business Server 2015 and Skype for Business Online support the following previously released clients: Lync 2013, Lync 2010, Lync 2010 Mobile, Lync Phone Edition, and Lync 2010 Attendant. For information about these clients when used with other servers, see the. Note: The Lync 2010 Attendant client is not supported in Skype for Business Online.

Article Delegate/2849 (95nov28 Www Clients For Mac Download

Note: The Skype for Business Web App browser client only provides. Contacts and Contact Groups support This table covers the features relating to managing IM and Presence contacts. Participants can't control desktops that are shared by Lync for Mac 2011 or Communicator for Mac 2011 users. Lync for Mac 2011 and Communicator for Mac 2011 users can control desktops shared by Windows users. This also won't work for Skype for Business Web App on Max OSX.

For Skype for Business Online, this feature requires Microsoft PSTN Conferencing, Exchange Unified Messaging, or a 3rd party audio conferencing provider. The Lync for Mac 2011 client cannot view Microsoft Office 2013 PowerPoint presentations when they have been shared in a conference by the Skype for Business Web App.

Feature/capability Skype for Business 2015 or 2016 client Skype for Business on Mac Client-side recording of audio, video, application sharing, desktop sharing, and uploaded content Client-side recording of file transfers, shared OneNote pages, and PowerPoint annotations Select preferred recording resolution Recording is unavailable in certain Skype for Business Online standalone plans. Recording requires full Skype for Business client rights. Recording of file transfers, shared OneNote pages, and PowerPoint annotations is unavailable in Skype for Business Online. Online or Hybrid user account limitations User accounts can exist either Online or On-premises, and that will affect the features available to that user. Users with accounts on Skype for Business Online will not have access to the following features, even with the Full client:.

Enhanced Presence: Use a photo from any public site for My Picture. Contacts: Search for Response Groups. IM Support: Persistent Chat (Group Chat) integration. IM Support: Escalate a Persistent Chat room to a Skype for Business Meeting with one click. External Users: Conduct two-party or multiparty calls with external users For more information check out this link:.