Gestione dei localizzatori di risorse uniformi
Un URL (Uniform Resource Locator) è una rappresentazione compatta della posizione e del metodo di accesso per una risorsa che si trova su Internet. Ogni URL è costituito da uno schema (HTTP, HTTPS o FTP) e da una stringa specifica dello schema. Questa stringa può includere anche una combinazione di un percorso di directory, una stringa di ricerca o un nome della risorsa. Le funzioni WinINet consentono di creare, combinare, suddividere e canonizzare gli URL. Per altre informazioni sugli URL, vedere RFC-1738 on Uniform Resource Locators (URL).
Le funzioni URL operano in modo orientato alle attività. Il contenuto e il formato dell'URL assegnato alla funzione non viene verificato. L'applicazione chiamante deve tenere traccia dell'uso di queste funzioni per assicurarsi che i dati siano nel formato previsto. Ad esempio, la funzione InternetCanonicalizeUrl convertirà il carattere "%" nella sequenza di escape "%25" quando non si usano flag. Se internetCanonicalizeUrl viene usato nell'URL canonizzato, la sequenza di escape "%25" verrà convertita nella sequenza di escape "%2525", che non funzionerebbe correttamente.
- che cos'è un URL canonico?
- Uso delle funzioni WinINet per gestire gli URL
- Canonicalizzazione degli URL
- Combinazione di URL Base e Relativi
- Cracking di URL
- Creazione di URL
- l'accesso diretto agli URL
Che cos'è un URL canonico?
Il formato di tutti gli URL deve seguire la sintassi e la semantica accettati per accedere alle risorse tramite Internet. La canonizzazione è il processo di formattazione di un URL per seguire questa sintassi e semantica accettata.
I caratteri che devono essere codificati includono tutti i caratteri che non hanno caratteri grafici corrispondenti nel set di caratteri codificati US-ASCII (esadecimale 80-FF, che non vengono utilizzati nel set di caratteri codificati US-ASCII, esadecimale 00-1F e 7F, che sono caratteri di controllo), spazi vuoti, "%" (che viene usato per codificare altri caratteri) e caratteri non sicuri (<, >, ", #, {, }, |, \, ^, ~, [, ]e ').
Uso delle funzioni WinINet per gestire gli URL
La tabella seguente riepiloga le funzioni URL.
| Funzione | Descrizione |
|---|---|
| InternetCanonicalizeUrl | Canonizza l'URL. |
| InternetCombineUrl | Combina gli URL di base e relativi. |
| InternetCrackUrl | Analizza una stringa URL in componenti. |
| InternetCreateUrl | Crea una stringa URL dai componenti. |
| InternetOpenUrl | Inizia a recuperare una risorsa FTP, HTTP o HTTPS. |
Canonizzazione degli URL
La canonizzazione di un URL è il processo che converte un URL, che potrebbe contenere caratteri non sicuri, ad esempio spazi vuoti, caratteri riservati e così via, in un formato accettato.
La funzione InternetCanonicalizeUrl può essere usata per canonizzare gli URL. Questa funzione è molto orientata alle attività, quindi l'applicazione deve tenere traccia attentamente dell'uso. InternetCanonicalizeUrl non verifica che l'URL passato sia già canonizzato e che l'URL restituito sia valido.
I cinque flag seguenti controllano come InternetCanonicalizeUrl gestisce un URL specifico. Le bandiere possono essere usate in combinazione. Se non vengono usati flag, la funzione codifica l'URL per impostazione predefinita.
| Valore | Significato |
|---|---|
| ICU_BROWSER_MODE | Non codificare o decodificare i caratteri dopo "#" o "?", e non rimuovere gli spazi vuoti finali dopo "?". Se questo valore non viene specificato, l'intero URL viene codificato e lo spazio vuoto finale viene rimosso. |
| ICU_DECODE | Convertire tutte le sequenze di %XX in caratteri, incluse le sequenze di escape, prima dell'analisi dell'URL. |
| ICU_ENCODE_SPACES_ONLY | Codifica solo gli spazi. |
| ICU_NO_ENCODE | Non convertire caratteri non sicuri in sequenze di escape. |
| ICU_NO_META | Non rimuovere le meta sequenze (ad esempio "." e "..") dall'URL. |
Il flag ICU_DECODE deve essere usato solo sugli URL canonici, perché presuppone che tutte le sequenze %XX siano codici di escape e le converta nei caratteri indicati dal codice. Se l'URL contiene un simbolo "%" che non fa parte di un codice di escape, ICU_DECODE lo considera ancora come uno. Questa caratteristica potrebbe causare a InternetCanonicalizeUrl di di creare un URL non valido.
Per utilizzare internetCanonicalizeUrl per restituire un URL completamente decodificato, è necessario specificare i flag ICU_DECODE e ICU_NO_ENCODE. Questa configurazione presuppone che l'URL passato a InternetCanonicalizeUrl sia stato precedentemente canonizzato.
Combinazione di URL di base e relativi
Un URL relativo è una rappresentazione compatta della posizione di una risorsa rispetto a un URL di base assoluto. L'URL di base deve essere noto al parser e in genere include lo schema, il percorso di rete e le parti del percorso URL. Un'applicazione può chiamare InternetCombineUrl per combinare l'URL relativo con il relativo URL di base. InternetCombineUrl canonizza anche l'URL risultante.
Cracking di URL
La funzione InternetCrackUrlsepara un URL nelle sue parti componenti e restituisce i componenti specificati dalla struttura URL_COMPONENTS passata alla funzione.
I componenti che costituiscono la struttura URL_COMPONENTS sono il numero di schema, il nome host, il numero di porta, il nome utente, la password, il percorso URL e le informazioni aggiuntive , ad esempio i parametri di ricerca. Ogni componente, ad eccezione dello schema e dei numeri di porta, ha un membro stringa che contiene le informazioni e un membro che contiene la lunghezza del membro stringa. Lo schema e i numeri di porta hanno solo un membro che archivia il valore corrispondente; vengono restituiti entrambi in tutte le chiamate riuscite a InternetCrackUrl.
Per ottenere il valore di un determinato componente nella struttura URL_COMPONENTS, il membro che archivia la lunghezza della stringa di tale componente deve essere impostato su un valore diverso da zero. Il membro stringa può essere l'indirizzo di un buffer o NULL.
Se il membro del puntatore contiene l'indirizzo di un buffer, il membro lunghezza della stringa deve contenere la dimensione di quel buffer. InternetCrackUrl restituisce le informazioni sul componente come stringa nel buffer e archivia la lunghezza della stringa nel membro di lunghezza della stringa.
Se il membro del puntatore è NULL, il membro della lunghezza della stringa può essere impostato su qualsiasi valore diverso da zero. InternetCrackUrl archivia l'indirizzo del primo carattere della stringa URL che contiene le informazioni sul componente e imposta la lunghezza della stringa sul numero di caratteri nella parte rimanente della stringa URL relativa al componente.
Tutti i membri del puntatore impostati su NULL che hanno una lunghezza diversa da zero puntano alla posizione iniziale appropriata nella stringa URL. La lunghezza memorizzata nel membro length deve essere utilizzata per determinare il termine delle informazioni relative al singolo componente.
Per completare correttamente l'inizializzazione della struttura URL_COMPONENTS, il membro dwStructSize deve essere impostato sulle dimensioni della struttura URL_COMPONENTS, in byte.
Nell'esempio seguente vengono restituiti i componenti dell'URL nella casella di modifica IDC_PreOpen1 e vengono restituiti i componenti alla casella di riepilogo IDC_PreOpenList. Per visualizzare solo le informazioni relative a un singolo componente, questa funzione copia il carattere immediatamente dopo le informazioni del componente nella stringa e lo sostituisce temporaneamente con un NULL.
#include <windows.h>
#include <tchar.h>
#include <strsafe.h>
#include <wininet.h>
#include <stdlib.h>
#pragma comment(lib, "wininet.lib")
#pragma comment(lib, "user32.lib")
#define CRACKER_BUFFER_SIZE MAX_PATH
// For sample source code implementing the InternetErrorOut( )
// function referenced below, see the "Handling Errors" topic
// under "Using WinInet"
extern BOOL WINAPI InternetErrorOut( HWND hWnd, DWORD dwError,
LPCTSTR szFailingFunctionName );
// Forward declaration of listUrlPart helper functions:
BOOL listURLpart( HWND hDlg, int nListBoxID,
LPTSTR szPartName, LPTSTR part, DWORD partLength );
BOOL listURLpart( HWND hDlg, int nListBoxID,
LPTSTR szPartName, int partValue );
// Static list describing the URL Scheme types
// enumerated in INTERNET_SCHEME:
TCHAR* schemeType[] =
{
TEXT( "[Partial URL]" ), // 0
TEXT( "[Unknown scheme]" ), // 1
TEXT( "[Default scheme]" ), // 2
TEXT( "FTP" ), // 3
TEXT( "Gopher" ), // 4
TEXT( "HTTP" ), // 5
TEXT( "HTTPS" ), // 6
TEXT( "File" ), // 7
TEXT( "News" ), // 8
TEXT( "MailTo" ), // 9
TEXT( "Socks" ), // 10
TEXT( "JavaScript" ), // 11
TEXT( "VBScript" ) // 12
};
#define CRACKER_SCHEME_TYPE_ARRAY_SIZE 13
BOOL WINAPI Cracker( HWND hDlg, int nURLtextBoxId, int nListBoxId )
{
int i, j;
TCHAR* failedFunctionName;
TCHAR URL_buffer[CRACKER_BUFFER_SIZE];
URL_COMPONENTS URLparts;
URLparts.dwStructSize = sizeof( URLparts );
// The following elements determine which components are displayed
URLparts.dwSchemeLength = 1;
URLparts.dwHostNameLength = 1;
URLparts.dwUserNameLength = 1;
URLparts.dwPasswordLength = 1;
URLparts.dwUrlPathLength = 1;
URLparts.dwExtraInfoLength = 1;
URLparts.lpszScheme = NULL;
URLparts.lpszHostName = NULL;
URLparts.lpszUserName = NULL;
URLparts.lpszPassword = NULL;
URLparts.lpszUrlPath = NULL;
URLparts.lpszExtraInfo = NULL;
SendDlgItemMessage( hDlg, nListBoxId, LB_RESETCONTENT, 0, 0 );
if( !GetDlgItemText( hDlg, nURLtextBoxId,
URL_buffer, CRACKER_BUFFER_SIZE ) )
{
failedFunctionName = TEXT( "GetDlgItemText" );
goto CrackerError_01;
}
if( FAILED( StringCchLength( URL_buffer, CRACKER_BUFFER_SIZE,
(size_t*) &i ) ) )
{
failedFunctionName = TEXT( "StringCchLength" );
goto CrackerError_01;
}
if( !InternetCrackUrl( URL_buffer, (DWORD)_tcslen( URL_buffer ), 0,
&URLparts ) )
{
failedFunctionName = TEXT( "InternetCrackUrl" );
goto CrackerError_01;
}
failedFunctionName = TEXT( "listURLpart" );
i = URLparts.nScheme + 2;
if( ( i >= 0 ) && ( i < CRACKER_SCHEME_TYPE_ARRAY_SIZE ) )
{
StringCchLength( schemeType[i],
CRACKER_BUFFER_SIZE,
(size_t*) &j );
if( !listURLpart( hDlg, nListBoxId,
TEXT("Scheme type"),
schemeType[i], j ))
goto CrackerError_01;
}
if( !listURLpart( hDlg, nListBoxId, TEXT( "Scheme text" ),
URLparts.lpszScheme,
URLparts.dwSchemeLength ) ||
!listURLpart( hDlg, nListBoxId, TEXT( "Host name" ),
URLparts.lpszHostName,
URLparts.dwHostNameLength) ||
!listURLpart( hDlg, nListBoxId, TEXT( "Port number" ),
(int) URLparts.nPort ) ||
!listURLpart( hDlg, nListBoxId, TEXT( "User name" ),
URLparts.lpszUserName,
URLparts.dwUserNameLength) ||
!listURLpart( hDlg, nListBoxId, TEXT( "Password" ),
URLparts.lpszPassword,
URLparts.dwPasswordLength) ||
!listURLpart( hDlg, nListBoxId, TEXT( "Path" ),
URLparts.lpszUrlPath,
URLparts.dwUrlPathLength) ||
!listURLpart( hDlg, nListBoxId, TEXT( "Extra information"),
URLparts.lpszExtraInfo,
URLparts.dwExtraInfoLength))
goto CrackerError_01;
return( TRUE );
CrackerError_01:
// For sample source code of the InternetErrorOut( ) function
// referenced below, see the "Handling Errors"
// topic under "Using WinInet"
InternetErrorOut( hDlg, GetLastError( ), failedFunctionName );
return FALSE;
}
// listURLpart( ) helper function for string parts
BOOL listURLpart( HWND hDlg, int nListBoxId,
LPTSTR szPartName, LPTSTR part, DWORD partLength )
{
TCHAR outputBuffer[CRACKER_BUFFER_SIZE];
LPTSTR nextStart;
size_t nextSize;
if( partLength == 0 ) // Just skip empty ones
return( TRUE );
if( FAILED( StringCchCopyEx( outputBuffer,
(size_t) CRACKER_BUFFER_SIZE,
szPartName, &nextStart,
&nextSize, 0 ) ) ||
FAILED( StringCchCopyEx( nextStart, nextSize, TEXT( ": " ),
&nextStart, &nextSize, 0 ) ) ||
FAILED( StringCchCopyNEx( nextStart, nextSize, part,
(size_t) partLength,
&nextStart, &nextSize, 0 ) ) )
return( FALSE );
*nextStart = 0;
if( SendDlgItemMessage( hDlg, nListBoxId, LB_ADDSTRING, 0,
(LPARAM)outputBuffer ) < 0 )
return( FALSE );
return( TRUE );
}
// listURLpart( ) helper function for numeric parts
BOOL listURLpart( HWND hDlg, int nListBoxId,
LPTSTR szPartName, int partValue )
{
TCHAR outputBuffer[CRACKER_BUFFER_SIZE];
if( FAILED( StringCchPrintf( outputBuffer,
(size_t) CRACKER_BUFFER_SIZE,
TEXT( "%s: %d" ), szPartName,
partValue ) ) ||
( SendDlgItemMessage( hDlg, nListBoxId, LB_ADDSTRING, 0,
(LPARAM)outputBuffer ) < 0 ) )
return( FALSE );
return( TRUE );
}
Creazione di URL
La funzioneInternetCreateUrlusa le informazioni nella struttura URL_COMPONENTS per creare un localizzatore di risorse uniformi.
I componenti che costituiscono la struttura URL_COMPONENTS sono lo schema, il nome host, il numero di porta, il nome utente, la password, il percorso URL e le informazioni aggiuntive , ad esempio i parametri di ricerca. Ogni componente, ad eccezione del numero di porta, ha un membro stringa che contiene le informazioni e un membro che contiene la lunghezza del membro stringa.
Per ogni componente necessario, il membro del puntatore deve contenere l'indirizzo del buffer contenente le informazioni. Il membro length deve essere impostato su zero se il membro del puntatore contiene l'indirizzo di una stringa con terminazione zero; Il membro length deve essere impostato sulla lunghezza della stringa se il membro del puntatore contiene l'indirizzo di una stringa che non termina con zero. Il membro puntatore di qualsiasi componente non richiesto deve essere NULL.
Accesso diretto agli URL
È possibile accedere direttamente alle risorse FTP e HTTP su Internet usando le funzioni InternetOpenUrl, InternetReadFilee InternetFindNextFile. InternetOpenUrl apre una connessione alla risorsa nell'URL passato alla funzione. Quando viene stabilita questa connessione, è possibile eseguire due passaggi. In primo luogo, se la risorsa è un file, InternetReadFile può scaricarla; in secondo luogo, se la risorsa è una directory, InternetFindNextFile può enumerare i file all'interno della directory (tranne quando si usano proxy CERN). Per altre informazioni su InternetReadFile, vedere Lettura di file. Per altre informazioni su InternetFindNextFile, vedere Ricerca del file successivo.
Per le applicazioni che devono operare tramite un proxy CERN, è possibile usare InternetOpenUrl per accedere a directory e file FTP. Le richieste FTP vengono incluse in un pacchetto come una richiesta HTTP, che il proxy CERN accetterebbe.
InternetOpenUrl usa l'handle HINTERNET creato dalla funzione InternetOpen e l'URL della risorsa. L'URL deve includere lo schema (http:, ftp:, file: [per un file locale]o https: [per il protocollo hypertext secure]) e il percorso di rete (ad esempio www.microsoft.com). L'URL può includere anche un percorso, ad esempio /isapi/gomscom.asp? TARGET=/windows/feature/) e il nome della risorsa (ad esempio, default.htm). Per le richieste HTTP o HTTPS, è possibile includere intestazioni aggiuntive.
InternetQueryDataAvailable, InternetFindNextFile, InternetReadFilee InternetSetFilePointer (solo URL HTTP o HTTPS) possono usare l'handle creato da InternetOpenUrl per scaricare la risorsa.
Il diagramma seguente illustra gli handle da usare con ogni funzione.
L'handle HINTERNET creato da InternetOpen viene utilizzato da InternetOpenUrl. L'handle di creato da InternetOpenUrl può essere utilizzato da InternetQueryDataAvailable, InternetReadFile, InternetFindNextFile (non illustrato qui) e InternetSetFilePointer (solo URL HTTP o HTTPS).
Per ulteriori informazioni, vedere handle di HINTERNET.
Nota
WinINet non supporta le implementazioni del server. Inoltre, non deve essere usato attraverso un servizio. Per le implementazioni del server o i servizi, usare Servizi HTTP Di Microsoft Windows (WinHTTP).