Publication d'une chaîne dans un serveur Web, obtention d'une réponse

Question

J'ai une longue chaîne de caractères codée en base64. Il s'agit d'environ 1024 caractères. A partir de mon code Objective C, je veux l'envoyer à mon script PHP, l'envoyer dans un journal et retourner une réponse "OK". J'ai essayé this cookbook example, mais il a seulement un exemple de télécharger et télécharger (pas les deux combinés), et il ne fonctionne même pas dans mon cas.

Je serais prêt à passer à une solution C++ si je savais comment.

L'objectif de code C client (ligne de commande client)

NSString *sMessage = @"My Long Base64 Encoded Message"; 
NSString *sURL = "http://example.com/request.php"; 
NSURL *oURL = [NSURL URLWithString:sURL]; 

NSData *data = [NSData dataWithBytes:sMessage.UTF8String length:sMessage.length]; 

NSURLSessionDataTask *downloadTask = [[NSURLSession sharedSession] 
    dataTaskWithURL:oURL completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) { 

    NSLog(@"\n\nDATA\n\n%@",data); 
    NSLog(@"\n\nRESPONSE\n\n%@",response); 
    NSLog(@"\n\nERROR\n\n%@",error); 

}]; 

[downloadTask resume]; 

Le PHP Web serveur de code

<?php 

error_reporting(E_ALL); 
ini_set('display_errors','On'); 
$sRaw = file_get_contents('php://input'); 
file_put_contents('TEST.TXT',$sRaw); 
die('OK'); 

Answer 1

Il y a une route beaucoup plus facile en utilisant C++ ordinaire. Vous devrez convertir votre fichier .m en un fichier .mm afin de pouvoir mélanger le code Objective C et C++.

Le code PHP est bon et ne nécessite pas de révision. Voici l'exemple C++ que j'ai utilisé qui a fonctionné. Il a utilisé le STL et curl. Je le faisais sur un Mac, et par défaut OSX a les bibliothèques curl pré-installées. Notez que l'exemple ci-dessous est synchrone: il bloque l'exécution du programme jusqu'à la fin de l'appel du serveur. (Je désiré dans mon cas -. Vous ne pouvez pas)

Le C++ code client (classe)

#pragma once 
#include <string> 
#include <sstream> 
#include <iostream> 
#include <curl/curl.h> 

class Webby { 

public: 

static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) { 
    std::string buf = std::string(static_cast<char *>(ptr), size * nmemb); 
    std::stringstream *response = static_cast<std::stringstream *>(stream); 
    response->write(buf.c_str(), (std::streamsize)buf.size()); 
    return size * nmemb; 
} 

static std::string sendRawHTTP(std::string sHostURL, std::string &sStringData) { 

    CURL *curl; 
    CURLcode res; 
    curl = curl_easy_init(); 
    if (curl) { 
     std::stringstream response; 
     curl_easy_setopt(curl, CURLOPT_URL, sHostURL.c_str()); 
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, sStringData.c_str()); 
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Webby::write_data); 
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response); 
     res = curl_easy_perform(curl); 
     curl_easy_cleanup(curl); 
     return response.str(); 
    } 
    return ""; 
} 

}; // end class