parseMultipartForm function

Future<MultipartForm> parseMultipartForm(
  1. EngineContext context
)

Parses multipart fields and stores uploaded files using engine settings.

Implementation

Future<MultipartForm> parseMultipartForm(EngineContext context) async {
  final request = context.request;
  final contentType = request.headers.contentType;
  final fileSystem = context.engineConfig.fileSystem;
  if (contentType == null ||
      contentType.primaryType != 'multipart' ||
      contentType.subType != 'form-data') {
    throw Exception('Not a multipart/form-data request');
  }
  final boundary = contentType.parameters['boundary'];
  if (boundary == null) {
    throw Exception('Missing boundary parameter');
  }
  final fields = <String, dynamic>{};
  final files = <MultipartFile>[];
  var totalBytesRead = 0;
  final quota = UploadQuotaTracker(context.engineConfig.multipart.maxDiskUsage);
  final createdFiles = <String>[];
  var parsingCompleted = false;
  try {
    await for (final part in MimeMultipartTransformer(
      boundary,
    ).bind(context.request.stream)) {
      final disposition = part.headers['content-disposition'] ?? '';
      final name = extractParam(disposition, 'name') ?? 'unnamed';
      final filename = extractParam(disposition, 'filename');
      if (filename != null) {
        final safeFilename = sanitizeFilename(filename);
        try {
          final savedPath = await storeFileWithLimit(
            allowedFileExtensions:
                context.engineConfig.multipart.allowedExtensions,
            maxFileSize: context.engineConfig.multipart.maxFileSize,
            uploadDirectory: context.engineConfig.multipart.uploadDirectory,
            filePermissions: context.engineConfig.multipart.filePermissions,
            quota: quota,
            part: part,
            safeFilename: safeFilename,
            fileSystem: fileSystem,
            onBytesRead: (chunkSize) {
              totalBytesRead += chunkSize;
              if (totalBytesRead > context.engineConfig.multipart.maxMemory) {
                final maxMemory = context.engineConfig.multipart.maxMemory;
                throw Exception('Request exceeded $maxMemory bytes');
              }
            },
          );
          createdFiles.add(savedPath);
          if (files.where((MultipartFile file) => file.name == name).isEmpty) {
            final savedFile = fileSystem.file(savedPath);
            files.add(
              MultipartFile(
                name: name,
                filename: filename,
                path: savedPath,
                size: await savedFile.length(),
                contentType:
                    part.headers['content-type'] ?? 'application/octet-stream',
              ),
            );
          }
        } on FileTooLargeException catch (_) {
          continue;
        }
      } else {
        final bytes = await part.fold<List<int>>([], (prev, chunk) {
          totalBytesRead += chunk.length;
          if (totalBytesRead > context.engineConfig.multipart.maxMemory) {
            final maxMemory = context.engineConfig.multipart.maxMemory;
            throw Exception('Request exceeded $maxMemory bytes');
          }
          return [...prev, ...chunk];
        });
        final value = utf8.decode(bytes);
        if (!fields.containsKey(name)) {
          fields[name] = value;
        } else {
          final existing = fields[name];
          if (existing is String) {
            fields[name] = [existing, value];
          } else if (existing is List) {
            existing.add(value);
          }
        }
      }
    }
    parsingCompleted = true;
  } finally {
    if (!parsingCompleted) {
      for (final path in createdFiles.reversed) {
        try {
          final file = fileSystem.file(path);
          if (await file.exists()) {
            quota.release(await file.length());
            await file.delete();
          }
        } on Object catch (_) {}
      }
      quota.reset();
    }
  }
  return MultipartForm(fields: fields, files: files);
}