GCDWebServer

https://github.com/swisspol/gcdwebserver
Admin
GCDWebServer is a modern and lightweight GCD-based HTTP 1.1 server designed to be embedded in iOS,...
Tokens:12,055
Snippets:86
Trust Score:-
License:BSD-3-Clause
Update:6 months ago
Show doc for...
Tokens:
Raw
### Create and Start a Basic GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Initializes a GCDWebServer, adds a default handler for GET requests, and starts the server on port 8080. Requires GCDWebServer and GCDWebServerDataResponse imports.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

// Create and configure server
GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Add a handler for GET requests on any URL
[webServer addDefaultHandlerForMethod:@"GET"
                         requestClass:[GCDWebServerRequest class]
                         processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    return [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
}];

// Start server on port 8080
NSError* error = nil;
if ([webServer startWithPort:8080 bonjourName:nil]) {
    NSLog(@"Server running at %@", webServer.serverURL);
} else {
    NSLog(@"Failed to start server: %@", error);
}

// To stop the server
[webServer stop];
```

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

### macOS Swift Command Line HTTP Server

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Set up a basic HTTP server using Swift on macOS. This example demonstrates adding a handler and starting the server.

```Swift
import Foundation
import GCDWebServer

func initWebServer() {

    let webServer = GCDWebServer()

    webServer.addDefaultHandler(forMethod: "GET", request: GCDWebServerRequest.self, processBlock: {request in
            return GCDWebServerDataResponse(html:"<html><body><p>Hello World</p></body></html>")
            
        })
        
    webServer.start(withPort: 8080, bonjourName: "GCD Web Server")
    
    print("Visit \(webServer.serverURL) in your web browser")
}
```

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

### Start GCDWebServer with Custom Options

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Starts a GCDWebServer with a dictionary of options for fine-grained control over port, Bonjour, authentication, and connection limits. Requires GCDWebServer import.

```objectivec
#import "GCDWebServer.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Configure server with options
NSDictionary* options = @{
    GCDWebServerOption_Port: @8080,
    GCDWebServerOption_BonjourName: @"My Web Server",
    GCDWebServerOption_BonjourType: @"_http._tcp",
    GCDWebServerOption_MaxPendingConnections: @16,
    GCDWebServerOption_ServerName: @"MyApp/1.0",
    GCDWebServerOption_BindToLocalhost: @NO,
    GCDWebServerOption_AutomaticallyMapHEADToGET: @YES,
    GCDWebServerOption_ConnectedStateCoalescingInterval: @1.0
};

NSError* error = nil;
if (![webServer startWithOptions:options error:&error]) {
    NSLog(@"Failed to start server: %@", error);
}
```

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

### Install GCDWebServer with Carthage

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Add this line to your Cartfile to install GCDWebServer using Carthage. Note that Carthage support started from version 3.2.5.

```plaintext
github "swisspol/GCDWebServer" ~> 3.2.5
```

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

### Install GCDWebServer with CocoaPods

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Add this line to your Podfile to install GCDWebServer using CocoaPods.

```ruby
pod "GCDWebServer", "~> 3.0"
```

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

### Install GCDWebDAVServer with CocoaPods

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

To use the GCDWebDAVServer extension, specify it in your Podfile.

```ruby
pod "GCDWebServer/WebDAV", "~> 3.0"
```

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

### Initialize GCDWebDAVServer in AppDelegate

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Configures and starts a WebDAV server within an iOS application delegate to serve the documents directory.

```objectivec
@interface AppDelegate : NSObject <UIApplicationDelegate> {
  GCDWebDAVServer* _davServer;
}
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
  NSString* documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
  _davServer = [[GCDWebDAVServer alloc] initWithUploadDirectory:documentsPath];
  [_davServer start];
  NSLog(@"Visit %@ in your WebDAV client", _davServer.serverURL);
  return YES;
}

@end
```

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

### Install GCDWebUploader with CocoaPods

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

To use the GCDWebUploader extension, specify it in your Podfile.

```ruby
pod "GCDWebServer/WebUploader", "~> 3.0"
```

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

### iOS HTTP Server

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Implement a basic HTTP server within an iOS application that responds with 'Hello World'. This example uses the AppDelegate to manage the server lifecycle.

```Objective-C
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

@interface AppDelegate : NSObject <UIApplicationDelegate> {
  GCDWebServer* _webServer;
}
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
  
  // Create server
  _webServer = [[GCDWebServer alloc] init];
  
  // Add a handler to respond to GET requests on any URL
  [_webServer addDefaultHandlerForMethod:@"GET"
                            requestClass:[GCDWebServerRequest class]
                            processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    
    return [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
    
  }];
  
  // Start server on port 8080
  [_webServer startWithPort:8080 bonjourName:nil];
  NSLog(@"Visit %@ in your web browser", _webServer.serverURL);
  
  return YES;
}

@end
```

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

### Implement GCDWebServerDelegate in Objective-C

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use the GCDWebServerDelegate protocol to monitor server lifecycle events such as start, stop, and connection status.

```objectivec
#import "GCDWebServer.h"

@interface MyServerController : NSObject <GCDWebServerDelegate>
@property (nonatomic, strong) GCDWebServer* webServer;
@end

@implementation MyServerController

- (void)setupServer {
    self.webServer = [[GCDWebServer alloc] init];
    self.webServer.delegate = self;
    // Add handlers...
    [self.webServer start];
}

- (void)webServerDidStart:(GCDWebServer*)server {
    NSLog(@"Server started on port %lu", (unsigned long)server.port);
    NSLog(@"Server URL: %@", server.serverURL);
}

- (void)webServerDidCompleteBonjourRegistration:(GCDWebServer*)server {
    NSLog(@"Bonjour registered: %@ (%@)", server.bonjourName, server.bonjourServerURL);
}

- (void)webServerDidConnect:(GCDWebServer*)server {
    NSLog(@"Client connected - HTTP requests incoming");
}

- (void)webServerDidDisconnect:(GCDWebServer*)server {
    NSLog(@"All clients disconnected");
}

- (void)webServerDidStop:(GCDWebServer*)server {
    NSLog(@"Server stopped");
}

@end
```

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

### Implement HTTP Forms with GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Demonstrates a pair of handlers for GET and POST requests, utilizing GCDWebServerURLEncodedFormRequest to automatically parse percent-encoded form bodies.

```objectivec
[webServer addHandlerForMethod:@"GET"
                          path:@"/"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
  
  NSString* html = @" \
    <html><body> \
      <form name=\"input\" action=\"/\" method=\"post\" enctype=\"application/x-www-form-urlencoded\"> \
      Value: <input type=\"text\" name=\"value\"> \
      <input type=\"submit\" value=\"Submit\"> \
      </form> \
    </body></html> \
  ";
  return [GCDWebServerDataResponse responseWithHTML:html];
  
}];

[webServer addHandlerForMethod:@"POST"
                          path:@"/"
                  requestClass:[GCDWebServerURLEncodedFormRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
  
  NSString* value = [[(GCDWebServerURLEncodedFormRequest*)request arguments] objectForKey:@"value"];
  NSString* html = [NSString stringWithFormat:@"<html><body><p>%@</p></body></html>", value];
  return [GCDWebServerDataResponse responseWithHTML:html];
  
}];
```

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

### Enable HTTP Basic or Digest Authentication

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Protect server endpoints with username/password credentials using Basic or Digest authentication. Digest authentication is more secure. This example configures Digest authentication with specified accounts.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

[webServer addDefaultHandlerForMethod:@"GET"
                         requestClass:[GCDWebServerRequest class]
                         processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    return [GCDWebServerDataResponse responseWithHTML:@"<p>Protected content</p>"];
}];

// Start with Digest authentication (more secure than Basic)
NSDictionary* options = @{
    GCDWebServerOption_Port: @8080,
    GCDWebServerOption_AuthenticationMethod: GCDWebServerAuthenticationMethod_DigestAccess,
    GCDWebServerOption_AuthenticationRealm: @"My Server",
    GCDWebServerOption_AuthenticationAccounts: @{
        @"admin": @"secretpassword",
        @"user": @"userpassword"
    }
};

// For Basic auth (less secure, passwords sent in clear):
// GCDWebServerOption_AuthenticationMethod: GCDWebServerAuthenticationMethod_Basic

NSError* error = nil;
[webServer startWithOptions:options error:&error];

```

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

### Handle Multipart File Uploads with GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Utilize GCDWebServerMultiPartFormRequest for handling file uploads encoded with multipart/form-data. This example shows serving an upload form and processing the uploaded file and its description.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"
#import "GCDWebServerMultiPartFormRequest.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Serve upload form
[webServer addHandlerForMethod:@"GET"
                          path:@"/upload"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSString* html = @"<html><body>"
                     @"<form method='post' action='/upload' enctype='multipart/form-data'>"
                     @"<input type='file' name='file'><br>"
                     @"<input type='text' name='description' placeholder='Description'><br>"
                     @"<input type='submit' value='Upload'>"
                     @"</form></body></html>";
    return [GCDWebServerDataResponse responseWithHTML:html];
}];

// Handle file upload
[webServer addHandlerForMethod:@"POST"
                          path:@"/upload"
                  requestClass:[GCDWebServerMultiPartFormRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    GCDWebServerMultiPartFormRequest* multipartRequest = (GCDWebServerMultiPartFormRequest*)request;

    // Get form arguments
    GCDWebServerMultiPartArgument* descArg = [multipartRequest firstArgumentForControlName:@"description"];
    NSString* description = descArg.string;

    // Get uploaded file
    GCDWebServerMultiPartFile* file = [multipartRequest firstFileForControlName:@"file"];
    if (file) {
        NSString* destPath = [NSTemporaryDirectory() stringByAppendingPathComponent:file.fileName];
        [[NSFileManager defaultManager] moveItemAtPath:file.temporaryPath toPath:destPath error:nil];
        NSString* html = [NSString stringWithFormat:@"<p>Uploaded %@ (%@)</p>", file.fileName, description];
        return [GCDWebServerDataResponse responseWithHTML:html];
    }
    return [GCDWebServerDataResponse responseWithHTML:@"<p>No file uploaded</p>"];
}];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Return Formatted Error Responses with GCDWebServerErrorResponse

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use GCDWebServerErrorResponse to return properly formatted error responses with HTTP status codes. This example demonstrates returning client errors (BadRequest, NotFound) and server errors (InternalServerError) with underlying error details.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerErrorResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

[webServer addHandlerForMethod:@"GET"
                     pathRegex:@"/api/resource/([0-9]+)"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSArray* captures = [request attributeForKey:GCDWebServerRequestAttribute_RegexCaptures];
    NSInteger resourceId = [captures.firstObject integerValue];

    // Simulate resource lookup
    if (resourceId == 0) {
        return [GCDWebServerErrorResponse responseWithClientError:kGCDWebServerHTTPStatusCode_BadRequest
                                                          message:@"Invalid resource ID"];
    }

    if (resourceId > 100) {
        return [GCDWebServerErrorResponse responseWithClientError:kGCDWebServerHTTPStatusCode_NotFound
                                                          message:@"Resource %ld not found", (long)resourceId];
    }

    // Simulate server error
    NSError* dbError = [NSError errorWithDomain:@"DBError" code:500 userInfo:nil];
    if (resourceId == 99) {
        return [GCDWebServerErrorResponse responseWithServerError:kGCDWebServerHTTPStatusCode_InternalServerError
                                                  underlyingError:dbError
                                                          message:@"Database connection failed"];
    }

    return [GCDWebServerDataResponse responseWithJSONObject:@{@"id": @(resourceId)}];
}];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Create JSON API Responses with GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use GCDWebServerDataResponse to return JSON-serialized objects. This handler automatically sets the content-type to application/json. It supports both GET for retrieving data and POST for creating or updating data, including validation for incoming JSON.

```Objective-C
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"
#import "GCDWebServerDataRequest.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// GET JSON endpoint
[webServer addHandlerForMethod:@"GET"
                          path:@"/api/items"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSArray* items = @[
        @{@"id": @1, @"name": @"Item 1", @"price": @9.99},
        @{@"id": @2, @"name": @"Item 2", @"price": @19.99}
    ];
    GCDWebServerDataResponse* response = [GCDWebServerDataResponse responseWithJSONObject:items];
    response.cacheControlMaxAge = 300; // Cache for 5 minutes
    return response;
}];

// POST JSON endpoint - receiving JSON data
[webServer addHandlerForMethod:@"POST"
                          path:@"/api/items"
                  requestClass:[GCDWebServerDataRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    GCDWebServerDataRequest* dataRequest = (GCDWebServerDataRequest*)request;
    NSDictionary* jsonBody = dataRequest.jsonObject;

    if (!jsonBody) {
        return [GCDWebServerDataResponse responseWithJSONObject:@{@"error": @"Invalid JSON"}];
    }

    NSDictionary* result = @{
        @"success": @YES,
        @"created": jsonBody,
        @"id": @([[NSDate date] timeIntervalSince1970])
    };
    GCDWebServerDataResponse* response = [GCDWebServerDataResponse responseWithJSONObject:result];
    response.statusCode = 201;
    return response;
}];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Serve a static directory with GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Demonstrates setting up a command-line tool to serve the home directory over HTTP on port 8080.

```objectivec
#import "GCDWebServer.h"

int main(int argc, const char* argv[]) {
  @autoreleasepool {
    
    GCDWebServer* webServer = [[GCDWebServer alloc] init];
    [webServer addGETHandlerForBasePath:@"/" directoryPath:NSHomeDirectory() indexFilename:nil cacheAge:3600 allowRangeRequests:YES];
    [webServer runWithPort:8080];
    
  }
  return 0;
}
```

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

### Configure Dynamic HTML Templates and Static File Handlers

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Sets up a web server to serve static files from a directory and uses a custom handler to process .html files with variable substitution. Includes a redirect handler for the root path.

```objectivec
// Get the path to the website directory
NSString* websitePath = [[NSBundle mainBundle] pathForResource:@"Website" ofType:nil];

// Add a default handler to serve static files (i.e. anything other than HTML files)
[self addGETHandlerForBasePath:@"/" directoryPath:websitePath indexFilename:nil cacheAge:3600 allowRangeRequests:YES];

// Add an override handler for all requests to "*.html" URLs to do the special HTML templatization
[self addHandlerForMethod:@"GET"
                pathRegex:@"/.*\.html"
             requestClass:[GCDWebServerRequest class]
             processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    
    NSDictionary* variables = [NSDictionary dictionaryWithObjectsAndKeys:@"value", @"variable", nil];
    return [GCDWebServerDataResponse responseWithHTMLTemplate:[websitePath stringByAppendingPathComponent:request.path]
                                                    variables:variables];
    
}];

// Add an override handler to redirect "/" URL to "/index.html"
[self addHandlerForMethod:@"GET"
                     path:@"/"
             requestClass:[GCDWebServerRequest class]
             processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    
    return [GCDWebServerResponse responseWithRedirect:[NSURL URLWithString:@"index.html" relativeToURL:request.URL]
                                            permanent:NO];
    
];
```

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

### Initialize GCDWebDAVServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Sets up a class 1 compliant WebDAV server for external client access.

```objectivec
#import "GCDWebDAVServer.h"

@interface AppDelegate () <GCDWebDAVServerDelegate>
@property (nonatomic, strong) GCDWebDAVServer* davServer;
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
    NSString* documentsPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;

    self.davServer = [[GCDWebDAVServer alloc] initWithUploadDirectory:documentsPath];
    self.davServer.delegate = self;
    self.davServer.allowedFileExtensions = nil; // Allow all extensions
    self.davServer.allowHiddenItems = NO;

    [self.davServer start];
    NSLog(@"Connect to %@ with a WebDAV client", self.davServer.serverURL);
    return YES;
}

// Delegate methods
- (void)davServer:(GCDWebDAVServer*)server didUploadFileAtPath:(NSString*)path {
    NSLog(@"File uploaded via WebDAV: %@", path);
}

- (void)davServer:(GCDWebDAVServer*)server didCopyItemFromPath:(NSString*)fromPath toPath:(NSString*)toPath {
    NSLog(@"Copied %@ to %@", fromPath, toPath);
}

@end
```

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

### Create a macOS Command Line Server

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Run a synchronous server in a command-line tool using runWithPort:bonjourName: until the process receives a termination signal.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

int main(int argc, const char* argv[]) {
    @autoreleasepool {
        GCDWebServer* webServer = [[GCDWebServer alloc] init];

        [webServer addDefaultHandlerForMethod:@"GET"
                                 requestClass:[GCDWebServerRequest class]
                                 processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
            return [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
        }];

        // Serve static files from home directory
        [webServer addGETHandlerForBasePath:@"/files/"
                              directoryPath:NSHomeDirectory()
                              indexFilename:nil
                                   cacheAge:3600
                         allowRangeRequests:YES];

        // Run synchronously until Ctrl-C
        [webServer runWithPort:8080 bonjourName:nil];
        NSLog(@"Server was running at %@", webServer.serverURL);
    }
    return 0;
}
```

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

### Initialize GCDWebUploader

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Configures a browser-based file manager with custom UI elements and file extension restrictions.

```objectivec
#import "GCDWebUploader.h"

@interface AppDelegate () <GCDWebUploaderDelegate>
@property (nonatomic, strong) GCDWebUploader* webUploader;
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
    NSString* documentsPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;

    self.webUploader = [[GCDWebUploader alloc] initWithUploadDirectory:documentsPath];
    self.webUploader.delegate = self;
    self.webUploader.title = @"My App Files";
    self.webUploader.header = @"File Manager";
    self.webUploader.prologue = @"<p>Upload and download files from your device</p>";
    self.webUploader.footer = @"MyApp v1.0";
    self.webUploader.allowedFileExtensions = @[@"pdf", @"jpg", @"png", @"txt"];
    self.webUploader.allowHiddenItems = NO;

    [self.webUploader start];
    NSLog(@"Visit %@ in your web browser", self.webUploader.serverURL);
    return YES;
}

// Delegate methods
- (void)webUploader:(GCDWebUploader*)uploader didUploadFileAtPath:(NSString*)path {
    NSLog(@"File uploaded: %@", path);
}

- (void)webUploader:(GCDWebUploader*)uploader didDownloadFileAtPath:(NSString*)path {
    NSLog(@"File downloaded: %@", path);
}

- (void)webUploader:(GCDWebUploader*)uploader didDeleteItemAtPath:(NSString*)path {
    NSLog(@"Item deleted: %@", path);
}

@end
```

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

### macOS Command Line HTTP Server

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Implement a basic HTTP server on macOS that responds with 'Hello World'. Ensure the libz shared system library is added to your Xcode target if not using CocoaPods.

```Objective-C
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

int main(int argc, const char* argv[]) {
  @autoreleasepool {
    
    // Create server
    GCDWebServer* webServer = [[GCDWebServer alloc] init];
    
    // Add a handler to respond to GET requests on any URL
    [webServer addDefaultHandlerForMethod:@"GET"
                             requestClass:[GCDWebServerRequest class]
                             processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
      
      return [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
      
    }];
    
    // Use convenience method that runs server on port 8080
    // until SIGINT (Ctrl-C in Terminal) or SIGTERM is received
    [webServer runWithPort:8080 bonjourName:nil];
    NSLog(@"Visit %@ in your web browser", webServer.serverURL);
    
  }
  return 0;
}
```

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

### Create HTTP Redirects

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Implement permanent (301) or temporary (302) redirects using the responseWithRedirect convenience method.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Permanent redirect (301)
[webServer addHandlerForMethod:@"GET"
                          path:@"/old-page"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSURL* newURL = [NSURL URLWithString:@"/new-page" relativeToURL:request.URL];
    return [GCDWebServerResponse responseWithRedirect:newURL permanent:YES];
}];

// Temporary redirect (302)
[webServer addHandlerForMethod:@"GET"
                          path:@"/"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    return [GCDWebServerResponse responseWithRedirect:[NSURL URLWithString:@"index.html" relativeToURL:request.URL]
                                            permanent:NO];
}];

[webServer startWithPort:8080 bonjourName:nil];
```

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

### Generate Dynamic HTML with Template Responses

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use HTML templates with variable substitution for dynamic page generation. This snippet shows how to load an HTML template and populate it with provided variables.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Assuming template.html contains: <html><body><h1>%title%</h1><p>%content%</p></body></html>
[webServer addHandlerForMethod:@"GET"
                     pathRegex:@"/page/.*\.html"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSString* templatePath = [[NSBundle mainBundle] pathForResource:@"template" ofType:@"html"];
    NSDictionary* variables = @{
        @"title": @"Welcome",
        @"content": @"This content was dynamically inserted!"
    };
    return [GCDWebServerDataResponse responseWithHTMLTemplate:templatePath variables:variables];
}];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Serve Static Files and Directories with GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

GCDWebServer can serve files from disk with automatic MIME type detection, caching, and range request support. This includes serving an entire directory, a specific file, or static data directly.

```Objective-C
#import "GCDWebServer.h"
#import "GCDWebServerFileResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Serve a static directory (e.g., website root)
NSString* websitePath = [[NSBundle mainBundle] pathForResource:@"Website" ofType:nil];
[webServer addGETHandlerForBasePath:@"/"
                      directoryPath:websitePath
                  indexFilename:@"index.html"
                       cacheAge:3600
             allowRangeRequests:YES];

// Serve a specific file
[webServer addGETHandlerForPath:@"/download/manual.pdf"
                       filePath:@"/path/to/manual.pdf"
                   isAttachment:YES  // Forces download instead of inline display
                       cacheAge:86400
             allowRangeRequests:YES];

// Serve static data (e.g., generated content)
NSData* staticData = [@"Static content" dataUsingEncoding:NSUTF8StringEncoding];
[webServer addGETHandlerForPath:@"/static.txt"
                     staticData:staticData
                    contentType:@"text/plain"
                       cacheAge:3600];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Integrate GCDWebServer with Swift

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Configure GCDWebServer in Swift using a bridging header to expose the Objective-C API.

```swift
import Foundation

// Bridging-Header.h should contain:
// #import <GCDWebServer/GCDWebServer.h>
// #import <GCDWebServer/GCDWebServerDataResponse.h>

class WebServerManager {
    let webServer = GCDWebServer()

    func startServer() {
        webServer.addDefaultHandler(forMethod: "GET",
                                    request: GCDWebServerRequest.self) { request in
            return GCDWebServerDataResponse(html: "<html><body><p>Hello from Swift!</p></body></html>")
        }

        webServer.addHandler(forMethod: "GET",
                            path: "/api/data",
                            request: GCDWebServerRequest.self) { request in
            let data: [String: Any] = ["message": "Hello", "timestamp": Date().timeIntervalSince1970]
            return GCDWebServerDataResponse(jsonObject: data)
        }

        webServer.start(withPort: 8080, bonjourName: "Swift Server")
        print("Visit \(webServer.serverURL!) in your web browser")
    }

    func stopServer() {
        webServer.stop()
    }
}
```

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

### Add Path-Specific Handlers to GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Adds handlers for specific HTTP methods and URL paths, including exact paths and regex patterns. Handlers are processed in LIFO order. Requires GCDWebServer and GCDWebServerDataResponse imports.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Handle GET requests to exact path "/api/status"
[webServer addHandlerForMethod:@"GET"
                          path:@"/api/status"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSDictionary* status = @{@"status": @"ok", @"version": @"1.0"};
    return [GCDWebServerDataResponse responseWithJSONObject:status];
}];

// Handle GET requests matching a regex pattern
[webServer addHandlerForMethod:@"GET"
                     pathRegex:@"/users/([0-9]+)"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    // Access regex captures from request attributes
    NSArray* captures = [request attributeForKey:GCDWebServerRequestAttribute_RegexCaptures];
    NSString* userId = captures.firstObject;
    NSDictionary* user = @{@"id": userId, @"name": @"John Doe"};
    return [GCDWebServerDataResponse responseWithJSONObject:user];
}];

[webServer startWithPort:8080 bonjourName:nil];
```

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

### Implement HTTP Redirects with GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Uses the convenience method on GCDWebServerResponse to automatically set the HTTP status code and Location header for a redirect.

```objectivec
[self addHandlerForMethod:@"GET"
                     path:@"/"
             requestClass:[GCDWebServerRequest class]
             processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    
  return [GCDWebServerResponse responseWithRedirect:[NSURL URLWithString:@"index.html" relativeToURL:request.URL]
                                          permanent:NO];
    
}];
```

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

### iOS WebDAV Server

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Set up a WebDAV server in an iOS app using GCDWebDAVServer. This enables file management via WebDAV clients.

```Objective-C
#import "GCDWebDAVServer.h"

```

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

### Serve Files with Byte Range Support using GCDWebServerFileResponse

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use GCDWebServerFileResponse to serve large files efficiently, supporting partial content requests (HTTP 206) and enabling resumable downloads. This handler checks for byte range requests and serves the appropriate portion of the file.

```Objective-C
#import "GCDWebServer.h"
#import "GCDWebServerFileResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

[webServer addHandlerForMethod:@"GET"
                     pathRegex:@"/videos/.*"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSString* videoPath = [NSString stringWithFormat:@"/path/to/videos%@", request.path];

    // Check if client requested a specific byte range
    if ([request hasByteRange]) {
        // Return partial content with the requested range
        GCDWebServerFileResponse* response = [GCDWebServerFileResponse responseWithFile:videoPath
                                                                              byteRange:request.byteRange];
        if (response) {
            return response;
        }
    }

    // Return full file
    GCDWebServerFileResponse* response = [GCDWebServerFileResponse responseWithFile:videoPath];
    return response ?: [GCDWebServerResponse responseWithStatusCode:404];
}];

[webServer startWithPort:8080 bonjourName:nil];

```

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

### Handle HTTP Requests Asynchronously in GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Use an asyncProcessBlock to return immediately and provide the response via a completion block once processing is finished.

```objectivec
[webServer addDefaultHandlerForMethod:@"GET"
                         requestClass:[GCDWebServerRequest class]
                    asyncProcessBlock:^(GCDWebServerRequest* request, GCDWebServerCompletionBlock completionBlock) {
  
  // Do some async operation like network access or file I/O (simulated here using dispatch_after())
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    GCDWebServerDataResponse* response = [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
    completionBlock(response);
  });

}];
```

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

### Handle HTTP Requests Synchronously in GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Use a standard process block to generate a response while the handler blocks execution.

```objectivec
[webServer addDefaultHandlerForMethod:@"GET"
                         requestClass:[GCDWebServerRequest class]
                         processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
  
  GCDWebServerDataResponse* response = [GCDWebServerDataResponse responseWithHTML:@"<html><body><p>Hello World</p></body></html>"];
  return response;
  
}];
```

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

### Render File Management Table Row

Source: https://github.com/swisspol/gcdwebserver/blob/master/GCDWebUploader/GCDWebUploader.bundle/Contents/Resources/index.html

Renders a table row for a file or folder, including action buttons for download, open, move, and delete.

```html
<tr class="row-file"> <td class="column-icon"> {% if (o.size != null) { %} <button type="button" class="btn btn-default btn-xs button-download"> <span class="glyphicon glyphicon-download-alt"></span> </button> {% } else { %} <button type="button" class="btn btn-default btn-xs button-open"> <span class="glyphicon glyphicon-folder-open"></span> </button> {% } %} </td> <td class="column-name"><p class="edit">{%=o.name%}</p></td> <td class="column-size"> {% if (o.size != null) { %} <p>{%=formatFileSize(o.size)%}</p> {% } %} </td> <td class="column-move"> <button type="button" class="btn btn-default btn-xs button-move"> <span class="glyphicon glyphicon glyphicon-share-alt"></span> </button> </td> <td class="column-delete"> <button type="button" class="btn btn-danger btn-xs button-delete"> <span class="glyphicon glyphicon-trash"></span> </button> </td> </tr>
```

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

### Implement Custom Match Block Handler

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Uses a match block to inspect request headers and conditionally route requests.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"
#import "GCDWebServerDataRequest.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Custom handler with match block for content negotiation
[webServer addHandlerWithMatchBlock:^GCDWebServerRequest*(NSString* requestMethod, NSURL* requestURL, NSDictionary* requestHeaders, NSString* urlPath, NSDictionary* urlQuery) {

    // Only handle if Accept header requests JSON
    NSString* accept = requestHeaders[@"Accept"];
    if ([requestMethod isEqualToString:@"GET"] &&
        [urlPath hasPrefix:@"/api/"] &&
        [accept containsString:@"application/json"]) {
        return [[GCDWebServerRequest alloc] initWithMethod:requestMethod
                                                       url:requestURL
                                                   headers:requestHeaders
                                                      path:urlPath
                                                     query:urlQuery];
    }
    return nil; // Let other handlers try

} processBlock:^GCDWebServerResponse*(GCDWebServerRequest* request) {
    return [GCDWebServerDataResponse responseWithJSONObject:@{@"api": @"response"}];
}];

[webServer startWithPort:8080 bonjourName:nil];
```

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

### Render File Upload Progress Row

Source: https://github.com/swisspol/gcdwebserver/blob/master/GCDWebUploader/GCDWebUploader.bundle/Contents/Resources/index.html

Renders a table row displaying the upload progress bar for a file.

```html
<tr class="row-file"> <td class="column-icon"> <button type="button" class="btn btn-warning btn-xs button-cancel"> <span class="glyphicon glyphicon-ban-circle"></span> </button> </td> <td class="column-path"><p>{%=o.path%}</p></td> <td class="column-progress"> <div class="progress"> <div class="progress-bar" id="progress-bar"></div> </div> </ts> </tr>
```

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

### Handle Asynchronous Requests with asyncProcessBlock

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use asyncProcessBlock to offload time-consuming operations to a background queue, preventing server blocking.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Async handler for time-consuming operations
[webServer addHandlerForMethod:@"GET"
                          path:@"/api/slow-operation"
                  requestClass:[GCDWebServerRequest class]
             asyncProcessBlock:^(GCDWebServerRequest* request, GCDWebServerCompletionBlock completionBlock) {

    // Perform slow operation on background queue
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // Simulate slow database query or network call
        [NSThread sleepForTimeInterval:2.0];

        NSDictionary* result = @{@"status": @"completed", @"data": @"Some result"};
        GCDWebServerDataResponse* response = [GCDWebServerDataResponse responseWithJSONObject:result];

        // Call completion block with the response
        completionBlock(response);
    });
}];

[webServer startWithPort:8080 bonjourName:nil];
```

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

### iOS Web-Based File Uploader

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Implement a file uploader and downloader in an iOS app using GCDWebUploader. This allows users to manage files from their web browser.

```Objective-C
#import "GCDWebUploader.h"

@interface AppDelegate : NSObject <UIApplicationDelegate> {
  GCDWebUploader* _webUploader;
}
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
  NSString* documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
  _webUploader = [[GCDWebUploader alloc] initWithUploadDirectory:documentsPath];
  [_webUploader start];
  NSLog(@"Visit %@ in your web browser", _webUploader.serverURL);
  return YES;
}

@end
```

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

### GCDWebServer Swift Bridging Header

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

This Objective-C header file is required to bridge GCDWebServer functionalities into Swift projects.

```Objective-C
#import <GCDWebServer/GCDWebServer.h>
#import <GCDWebServer/GCDWebServerDataResponse.h>
```

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

### Render Alert Notification

Source: https://github.com/swisspol/gcdwebserver/blob/master/GCDWebUploader/GCDWebUploader.bundle/Contents/Resources/index.html

Renders a dismissable alert box for displaying status messages.

```html
<div class="alert alert-{%=o.level%} alert-dismissable"> <button type="button" class="close" data-dismiss="alert">&times;</button> <strong>{%=o.title%}</strong>{%=o.description%} </div>
```

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

### Generate Streamed Responses

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Utilize GCDWebServerStreamedResponse for generating large or dynamic content on-the-fly, supporting both synchronous and asynchronous stream blocks.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerStreamedResponse.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Synchronous streamed response
[webServer addHandlerForMethod:@"GET"
                          path:@"/stream"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {

    __block int counter = 0;
    return [GCDWebServerStreamedResponse responseWithContentType:@"text/plain"
                                                     streamBlock:^NSData *(NSError** error) {
        if (counter < 10) {
            NSString* chunk = [NSString stringWithFormat:@"Chunk %d\n", counter++];
            return [chunk dataUsingEncoding:NSUTF8StringEncoding];
        }
        return [NSData data]; // Empty data signals end of stream
    }];
}];

// Async streamed response for truly asynchronous data generation
[webServer addHandlerForMethod:@"GET"
                          path:@"/async-stream"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {

    __block NSMutableArray* data = [@[@"First\n", @"Second\n", @"Third\n"] mutableCopy];
    return [GCDWebServerStreamedResponse responseWithContentType:@"text/plain"
                                                asyncStreamBlock:^(GCDWebServerBodyReaderCompletionBlock completionBlock) {
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 500 * NSEC_PER_MSEC),
                       dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            if (data.count > 0) {
                NSString* chunk = data.firstObject;
                [data removeObjectAtIndex:0];
                completionBlock([chunk dataUsingEncoding:NSUTF8StringEncoding], nil);
            } else {
                completionBlock([NSData data], nil); // End of stream
            }
        });
    }];
}];

[webServer startWithPort:8080 bonjourName:nil];
```

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

### Stream HTTP Responses Asynchronously in GCDWebServer

Source: https://github.com/swisspol/gcdwebserver/blob/master/README.md

Use GCDWebServerStreamedResponse with an asyncStreamBlock to generate response content incrementally.

```objectivec
[webServer addDefaultHandlerForMethod:@"GET"
                         requestClass:[GCDWebServerRequest class]
                         processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
  
  NSMutableArray* contents = [NSMutableArray arrayWithObjects:@"<html><body><p>\n", @"Hello World!\n", @"</p></body></html>\n", nil];  // Fake data source we are reading from
  GCDWebServerStreamedResponse* response = [GCDWebServerStreamedResponse responseWithContentType:@"text/html" asyncStreamBlock:^(GCDWebServerBodyReaderCompletionBlock completionBlock) {
    
    // Simulate a delay reading from the fake data source
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      NSString* string = contents.firstObject;
      if (string) {
        [contents removeObjectAtIndex:0];
        completionBlock([string dataUsingEncoding:NSUTF8StringEncoding], nil);  // Generate the 2nd part of the stream data
      } else {
        completionBlock([NSData data], nil);  // Must pass an empty NSData to signal the end of the stream
      }
    });
    
  }];
  return response;
  
}];
```

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

### Handle URL-encoded Form Submissions with GCDWebServer

Source: https://context7.com/swisspol/gcdwebserver/llms.txt

Use GCDWebServerURLEncodedFormRequest to automatically parse URL-encoded form data from POST requests. This snippet demonstrates serving an HTML form and processing its submission.

```objectivec
#import "GCDWebServer.h"
#import "GCDWebServerDataResponse.h"
#import "GCDWebServerURLEncodedFormRequest.h"

GCDWebServer* webServer = [[GCDWebServer alloc] init];

// Serve the HTML form
[webServer addHandlerForMethod:@"GET"
                          path:@"/"
                  requestClass:[GCDWebServerRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    NSString* html = @"<html><body>"
                     @"<form method='post' action='/' enctype='application/x-www-form-urlencoded'>"
                     @"Name: <input type='text' name='name'><br>"
                     @"Email: <input type='email' name='email'><br>"
                     @"<input type='submit' value='Submit'>"
                     @"</form></body></html>";
    return [GCDWebServerDataResponse responseWithHTML:html];
}];

// Handle form submission
[webServer addHandlerForMethod:@"POST"
                          path:@"/"
                  requestClass:[GCDWebServerURLEncodedFormRequest class]
                  processBlock:^GCDWebServerResponse *(GCDWebServerRequest* request) {
    GCDWebServerURLEncodedFormRequest* formRequest = (GCDWebServerURLEncodedFormRequest*)request;
    NSString* name = formRequest.arguments[@"name"];
    NSString* email = formRequest.arguments[@"email"];
    NSString* html = [NSString stringWithFormat:@"<html><body><p>Hello %@ (%@)</p></body></html>", name, email];
    return [GCDWebServerDataResponse responseWithHTML:html];
}];

[webServer startWithPort:8080 bonjourName:nil];

```
Tokens:
Raw