Sending Apple Push Notifications (APN) in C - Updated (Using CA Cert)

原文转载自：

http://blog.toshsoft.de/index.php?/archives/3-Sending-Apple-Push-Notifications-APN-in-C-Updated-Using-CA-Cert.html

Update 22.01.2012: Thanks to asmera I discovered, that Apple seems to be stricter with the JSON you send and that since a few days the Apple Servers do not accept the output from the example given here. I changed the code in here as well as in the downloadable example to make it work again.

-----------------------------------------

Today I will show you a quick implementation of an Apple Push Notification Server provider in C. (Now updated with the new Entrust CA cert and instructions how to use it. For information on how to trust it go here) Some parts of this (like creating the needed certificates) are taken from this very good tutorial about building the same thing in php. For a good intro on the topic and how APNs works internally you should first read this.

You're done? Good, then let's get started:

First you need to create the Push Certificates and enable your application to get notified:

1. Log in to the iPhone Developer Connection Portal and click App IDs Ensure you have created an App ID without a wildcard. Wildcard IDs cannot use the push notification service. For example, our iPhone application ID looks something like AB123346CD.com.serverdensity.iphone

2. Click Configure next to your App ID and then click the button to generate a Push Notification certificate. A wizard will appear guiding you through the steps to generate a signing authority and then upload it to the portal, then download the newly generated certificate. This step is also covered in the Apple documentation.

3. Import your aps_developer_identity.cer into your Keychain by double clicking the .cer file. Launch Keychain Assistant from your local Mac and from the login keychain, filter by the Certificates category. You will see an expandable option called “Apple Development Push Services”

4. Expand this option then right click on “Apple Development Push Services” > Export “Apple Development Push Services ID123″. Save this as apns-dev-cert.p12 file somewhere you can access it.

5. Do the same again for the “Private Key” that was revealed when you expanded “Apple Development Push Services” ensuring you save it as apns-dev-key.p12 file.

6. These files now need to be converted to the PEM format by executing this command from the terminal:

openssl pkcs12 -clcerts -nokeys -out apns-dev-cert.pem -in apns-dev-cert.p12
openssl pkcs12 -nocerts -out apns-dev-key-enc.pem -in apns-dev-key.p12

Then to remove the passphrase execute:

openssl rsa -in apns-dev-key-enc.pem -out apns-dev-key.pem

Once we are finished, this little example program will help us testing if we did everything right.

1.  
2. #include
3. #include
4. #include
5.  
6. #include "Helper/RemoteNotification.h"
7.  
8. /* MAIN Function */
9. int main(int argc, char *argv[])
10. {
11.     int     err;
12.  
13.     /* Phone specific Payload message as well as hex formated device token */
14.     const char     *deviceTokenHex = NULL;
15.     if(argc == 1)
16.     {
17.         deviceTokenHex = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
18.     }
19.     else
20.     {
21.         deviceTokenHex = argv[1];
22.     }
23.  
24.     if(strlen(deviceTokenHex) < 64 || strlen(deviceTokenHex) > 70)
25.     {
26.         ("Device Token is to short or to long. Length without spaces should be 64 chars...\n");
27.         exit(1);
28.     }
29.    
30.     Payload *payload = (Payload*)malloc(sizeof(Payload));
31.     init_payload(payload);
32.  
33.     // This is the message the user gets once the Notification arrives
34.     payload->message = "Message to print out";
35.  
36.     // This is the red numbered badge that appears over the Icon
37.     payload->badgeNumber = 1;
38.  
39.     // This is the Caption of the Action key on the Dialog that appears
40.     payload->actionKeyCaption = "Caption of the second Button";
41.  
42.     // These are two dictionary key-value pairs with user-content
43.     payload->dictKey[0] = "Key1";
44.     payload->dictValue[0] = "Value1";
45.  
46.     payload->dictKey[1] = "Key2";
47.     payload->dictValue[1] = "Value2";
48.  
49.     /* Send the payload to the phone */
50.     ("Sending APN to Device with UDID: %s\n", deviceTokenHex);
51.     send_remote_notification(deviceTokenHex, payload);
52.  
53.     return 0;
54. }
55.  

send_remote_notification does everything we need. It first prepares the payload, which is encapsulated into a struct:

1.  
2. typedef struct {
3.     /* The Message that is displayed to the user */
4.     char *message;
5.  
6.     /* The name of the Sound which will be played back */
7.     char *soundName;
8.  
9.     /* The Number which is plastered over the icon, 0 disables it */
10.     int badgeNumber;
11.  
12.     /* The Caption of the Action Key the user needs to press to launch the Application */
13.     char *actionKeyCaption;
14.  
15.     /* Custom Message Dictionary, which is accessible from the Application */
16.     char* dictKey[5];
17.     char* dictValue[5];
18. } Payload;
19.  
20. #define DEVICE_BINARY_SIZE  32
21. #define MAXPAYLOAD_SIZE     256
22.  

From the given Information JSON is generated (JSON is described ) and then sent. It is implemented as follows:

1.  
2. int send_remote_notification(const char *deviceTokenHex, Payload *payload)
3. {
4.         char messageBuff[MAXPAYLOAD_SIZE];
5.         char tmpBuff[MAXPAYLOAD_SIZE];
6.         char badgenumBuff[3];
7.  
8.         strcpy(messageBuff, "{\"aps\":{");
9.  
10.         if(payload->message != NULL)
11.         {
12.             strcat(messageBuff, "\"alert\":");
13.             if(payload->actionKeyCaption != NULL)
14.             {
15.                 sprintf(tmpBuff, "{\"body\":\"%s\",\"action-loc-key\":\"%s\"},", payload->message, payload->actionKeyCaption);
16.                 strcat(messageBuff, tmpBuff);
17.             }
18.             else
19.             {
20.                 sprintf(tmpBuff, "{\"%s\"},", payload->message);
21.                 strcat(messageBuff, tmpBuff);
22.             }
23.         }
24.  
25.         if(payload->badgeNumber > 99 || payload->badgeNumber < 0)
26.             payload->badgeNumber = 1;
27.  
28.         sprintf(badgenumBuff, "%d", payload->badgeNumber);
29.         strcat(messageBuff, "\"badge\":");
30.         strcat(messageBuff, badgenumBuff);
31.  
32.         strcat(messageBuff, ",\"sound\":\"");
33.         strcat(messageBuff, payload->soundName == NULL ? "default" : payload->soundName);
34.         strcat(messageBuff, "\"},");
35.  
36.         int i = 0;
37.         while(payload->dictKey[i] != NULL && i < 5)
38.         {
39.             sprintf(tmpBuff, "\"%s\":\"%s\"", payload->dictKey[i], payload->dictValue[i]);
40.             strcat(messageBuff, tmpBuff);
41.             if(i < 4 && payload->dictKey[i + 1] != NULL)
42.             {
43.                 strcat(messageBuff, ",");
44.             }
45.             i++;
46.         }
47.  
48.         strcat(messageBuff, "}");
49.         ("Sending %s\n", messageBuff);
50.  
51.         send_payload(deviceTokenHex, messageBuff, strlen(messageBuff));
52. }
53.  

It allows up to 5 custom key-value pairs in a custom dictionary. After the method is done formatting, the sending process is initiated by calling the send_payload function. The payload can be sent either through the development push server or the production push server, depending on the used certificate. For this purpose a define is used, which selects the right type depending on the build.

1.  
2.     #define CA_CERT_PATH    "/path/to/the/ca/cert"
3.  
4. #if defined(IS_DEVELOPMENT_VERSION)
5.     /* Development Certificates */
6.     #define RSA_CLIENT_CERT     "Certs/apns-dev-cert.pem"
7.     #define RSA_CLIENT_KEY      "Certs/apns-dev-key.pem"
8.  
9.     /* Development Connection Infos */
10.     #define APPLE_HOST          "gateway.sandbox.push.apple.com"
11.     #define APPLE_PORT          2195
12.  
13.     #define APPLE_FEEDBACK_HOST "feedback.sandbox.push.apple.com"
14.     #define APPLE_FEEDBACK_PORT 2196
15. #else
16.     /* Distribution Certificates */
17.     #define RSA_CLIENT_CERT     "Certs/apns-dis-cert.pem"
18.     #define RSA_CLIENT_KEY      "Certs/apns-dis-key.pem"
19.  
20.     /* Release Connection Infos */
21.     #define APPLE_HOST          "gateway.push.apple.com"
22.     #define APPLE_PORT          2195
23.  
24.     #define APPLE_FEEDBACK_HOST "feedback.push.apple.com"
25.     #define APPLE_FEEDBACK_PORT 2196
26. #endif
27.  

1.  
2. int send_payload(const char *deviceTokenHex, const char *payloadBuff, size_t payloadLength)
3. {
4.     int rtn = 0;
5.  
6.     SSL_Connection *sslcon = ssl_connect(APPLE_HOST, APPLE_PORT, RSA_CLIENT_CERT,RSA_CLIENT_KEY, CA_CERT_PATH);
7.     if(sslcon == NULL)
8.     {
9.         ("Could not allocate memory for SSL Connection");
10.         exit(1);
11.     }
12.  
13.     if (sslcon && deviceTokenHex && payloadBuff && payloadLength)
14.     {
15.         uint8_t command = 0; /* command number */
16.         char binaryMessageBuff[sizeof(uint8_t) + sizeof(uint16_t) + DEVICE_BINARY_SIZE +sizeof(uint16_t) + MAXPAYLOAD_SIZE];
17.  
18.         /* message format is, |COMMAND|TOKENLEN|TOKEN|PAYLOADLEN|PAYLOAD| */
19.         char *binaryMessagePt = binaryMessageBuff;
20.         uint16_t networkOrderTokenLength = htons(DEVICE_BINARY_SIZE);
21.         uint16_t networkOrderPayloadLength = htons(payloadLength);
22.  
23.         /* command */
24.         *binaryMessagePt++ = command;
25.  
26.         /* token length network order */
27.         memcpy(binaryMessagePt, &networkOrderTokenLength, sizeof(uint16_t));
28.         binaryMessagePt += sizeof(uint16_t);
29.  
30.         /* Convert the Device Token */
31.         int i = 0;
32.         int j = 0;
33.         int tmpi;
34.         char tmp[3];
35.         char deviceTokenBinary[DEVICE_BINARY_SIZE];
36.         while(i < strlen(deviceTokenHex))
37.         {
38.             if(deviceTokenHex[i] == ' ')
39.             {
40.                 i++;
41.             }
42.             else
43.             {
44.                 tmp[0] = deviceTokenHex[i];
45.                 tmp[1] = deviceTokenHex[i + 1];
46.                 tmp[2] = '\0';
47.  
48.                 sscanf(tmp, "%x", &tmpi);
49.                 deviceTokenBinary[j] = tmpi;
50.  
51.                 i += 2;
52.                 j++;
53.             }
54.         }
55.  
56.         /* device token */
57.         memcpy(binaryMessagePt, deviceTokenBinary, DEVICE_BINARY_SIZE);
58.         binaryMessagePt += DEVICE_BINARY_SIZE;
59.  
60.         /* payload length network order */
61.         memcpy(binaryMessagePt, &networkOrderPayloadLength, sizeof(uint16_t));
62.         binaryMessagePt += sizeof(uint16_t);
63.  
64.         /* payload */
65.         memcpy(binaryMessagePt, payloadBuff, payloadLength);
66.         binaryMessagePt += payloadLength;
67.         if (SSL_write(sslcon->ssl, binaryMessageBuff, (binaryMessagePt - binaryMessageBuff)) >0)
68.             rtn = 1;
69.     }
70.  
71.     ssl_disconnect(sslcon);
72.  
73.     return rtn;
74. }
75.  

We're nearly done with the server part, the last (and hardest ) puzzle piece is the SSL connection, which is wrapped in a neat structure:

1.  
2. typedef struct {
3.     /* SSL Vars */
4.     SSL_CTX         *ctx;
5.     SSL             *ssl;
6.     SSL_METHOD      *meth;
7.     X509            *server_cert;
8.     EVP_PKEY        *pkey;
9.  
10.     /* Socket Communications */
11.     struct sockaddr_in   server_addr;
12.     struct hostent      *host_info;
13.     int                  sock;
14. } SSL_Connection;
15.  

So let's get right to using it:

1.  
2. SSL_Connection *ssl_connect(const char *host, int port, const char *certfile, const char*keyfile, const char* capath)
3. {
4.     int err;
5.  
6.     SSL_Connection *sslcon = NULL;
7.     sslcon = (SSL_Connection *)malloc(sizeof(SSL_Connection));
8.     if(sslcon == NULL)
9.     {
10.         ("Could not allocate memory for SSL Connection");
11.         exit(1);
12.     }
13.  
14.     /* Load encryption & hashing algorithms for the SSL program */
15.     SSL_library_init();
16.  
17.     /* Load the error strings for SSL & CRYPTO APIs */
18.     SSL_load_error_strings();
19.  
20.     /* Create an SSL_METHOD structure (choose an SSL/TLS protocol version) */
21.     sslcon->meth = SSLv3_method();
22.  
23.     /* Create an SSL_CTX structure */
24.     sslcon->ctx = SSL_CTX_new(sslcon->meth);                        
25.     if(!sslcon->ctx)
26.     {
27.         ("Could not get SSL Context\n");
28.         exit(1);
29.     }
30.  
31.     /* Load the CA from the Path */
32.     if(SSL_CTX_load_verify_locations(sslcon->ctx, NULL, capath) <= 0)
33.     {
34.         /* Handle failed load here */
35.         ("Failed to set CA location...\n");
36.         ERR_print_errors_fp(stderr);
37.         exit(1);
38.     }
39.  
40.     /* Load the client certificate into the SSL_CTX structure */
41.     if (SSL_CTX_use_certificate_file(sslcon->ctx, certfile, SSL_FILETYPE_PEM) <= 0) {
42.         ("Cannot use Certificate File\n");
43.         ERR_print_errors_fp(stderr);
44.         exit(1);
45.     }
46.  
47.     /* Load the private-key corresponding to the client certificate */
48.     if (SSL_CTX_use_PrivateKey_file(sslcon->ctx, keyfile, SSL_FILETYPE_PEM) <= 0) {
49.         ("Cannot use Private Key\n");
50.         ERR_print_errors_fp(stderr);
51.         exit(1);
52.     }
53.  
54.     /* Check if the client certificate and private-key matches */
55.     if (!SSL_CTX_check_private_key(sslcon->ctx)) {
56.         ("Private key does not match the certificate public key\n");
57.         exit(1);
58.     }
59.  
60.     /* Set up a TCP socket */
61.     sslcon->sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);      
62.     if(sslcon->sock == -1)
63.     {
64.         ("Could not get Socket\n");
65.         exit(1);
66.     }
67.  
68.     memset (&sslcon->server_addr, '\0', sizeof(sslcon->server_addr));
69.     sslcon->server_addr.sin_family      = AF_INET;
70.     sslcon->server_addr.sin_port        = htons(port);       /* Server Port number */
71.     sslcon->host_info = gethostbyname(host);
72.     if(sslcon->host_info)
73.     {
74.         /* Take the first IP */
75.         struct in_addr *address = (struct in_addr*)sslcon->host_info->h_addr_list[0];
76.         sslcon->server_addr.sin_addr.s_addr = inet_addr(inet_ntoa(*address)); /* Server IP */
77.     }
78.     else
79.     {
80.         ("Could not resolve hostname %s\n", host);
81.         return NULL;
82.     }
83.  
84.     /* Establish a TCP/IP connection to the SSL client */
85.     err = connect(sslcon->sock, (struct sockaddr*) &sslcon->server_addr, sizeof(sslcon->server_addr));
86.     if(err == -1)
87.     {
88.         ("Could not connect\n");
89.         exit(1);
90.     }    
91.  
92.     /* An SSL structure is created */
93.     sslcon->ssl = SSL_new(sslcon->ctx);
94.     if(!sslcon->ssl)
95.     {
96.         ("Could not get SSL Socket\n");
97.         exit(1);
98.     }    
99.  
100.     /* Assign the socket into the SSL structure (SSL and socket without BIO) */
101.     SSL_set_fd(sslcon->ssl, sslcon->sock);
102.  
103.     /* Perform SSL Handshake on the SSL client */
104.     err = SSL_connect(sslcon->ssl);
105.     if(err <= 0)
106.     {
107.         ("Could not connect to SSL Server\n");
108.         exit(1);
109.     }
110.  
111.     return sslcon;
112. }
113.  
114. void ssl_disconnect(SSL_Connection *sslcon)
115. {
116.     int err;
117.  
118.     if(sslcon == NULL)
119.     {
120.         return;
121.     }
122.  
123.     /* Shutdown the client side of the SSL connection */
124.     err = SSL_shutdown(sslcon->ssl);
125.     if(err == -1)
126.     {
127.         ("Could not shutdown SSL\n");
128.         exit(1);
129.     }    
130.  
131.     /* Terminate communication on a socket */
132.     err = close(sslcon->sock);
133.     if(err == -1)
134.     {
135.         ("Could not close socket\n");
136.         exit(1);
137.     }    
138.  
139.     /* Free the SSL structure */
140.     SSL_free(sslcon->ssl);
141.  
142.     /* Free the SSL_CTX structure */
143.     SSL_CTX_free(sslcon->ctx);
144.  
145.     /* Free the sslcon */
146.     if(sslcon != NULL)
147.     {
148.         free(sslcon);
149.         sslcon = NULL;
150.     }
151. }
152.  

Remember, as I told in the beginning, this is a quick implementation, so don't count on it being flawless.  But if you still want it, you can download the complete Project from  (updated 22.01.2012)

You can use this code and modify it as you see fit, but if you find it useful or found something wrong or missing, a comment would be nice.

Posted by Oliver Pahl in C++, iPhone, Objective C Comments: (12) Trackbacks: (0)

Trackbacks

Trackback specific URI for this entry

No Trackbacks

Comments

Display comments as (Linear | Threaded)

A great example for apple's push service.

You should make examples for the developers.

Great code ... great documentation !!!

Great work !!!!

#1  on 2011-04-29 11:31 (Reply)

When you call SSL_connect, you check that the result is not -1. Isn't 0 an error too, per the SSL documentation?

I am getting a zero return from the SSL_connect call.

Thanks for the great tutorial,

Sanjay

#1.1  on 2011-11-17 21:29 (Reply)

Hi

Yes, that is true, thanks for pointing it out.

The problem with this example implementation is, that the error handling as such is nearly non-existent anyway. I changed the check to (err <= 0) for now, and if I find the time I will update it with the correct error handling and the returned errors you get through SSL_get_error().

Best regards

#1.1.1  on 2011-11-17 22:23 (Reply)

Brilliant. Haven't got it going yet, but this is the *_only_* non-PHP code for doing this I've found. Apple's partial example was way too partial.

I'm planning to port it to objective-c and wrap it in a class if I can.

Thanks heaps.

#2  () on 2011-06-28 15:57 (Reply)

Always a good job right here. Keep rolling on through.

#2.1  () on 2011-09-06 18:32 (Reply)

It works! A little polishing yet, and then I'm done!

Thanks so much. Once I'm done, I'll blog it and link back to here.

Peter

#3  () on 2011-07-01 17:52 (Reply)

Hi Its really Great work .

#4  on 2011-12-07 13:26 (Reply)

Hi,

I reuse your code to to make an engine that works with beanstalkd queue engine. It's currently draft, but will hopefully be nice later.. See pushMessageEngine on github. Thanks for your original contribution that helped a lot.

Seb

#5  () on 2011-12-10 12:21 (Reply)

I am now trying this demo. it seems easy to use.

Thank you very much!

Great Job!

#6 tiara on 2011-12-23 11:06 (Reply)

in RemoteNotification.c

60 strcat(messageBuff, "\"},");

61 //strcat(messageBuff, "\"}");

Building, but did not send. Are the above changes could send.

#7  on 2012-01-22 05:04 (Reply)

Hi

it seems Apple changed how they handle the received JSON and that broke the old implementation. I have no PC right now, but I will update the post and source code first thing in the morning.

Thanks for the hint and best regards

Oliver

#7.1  on 2012-01-22 05:46 (Reply)

Sorry, I forgot to say.

Thanks for providing the source code.

#7.1.1  on 2012-01-22 06:22 (Reply)