protected void btnFromPcUpload_Click(object sender, EventArgs e)
        {
            try
            {
                if (!filePcUpload.HasFile)
                {
                    AddError("No file is selected!");
                    return;
                }
                using (var db = new UploadDb())
                {
                    var fileName    = Path.GetFileName(filePcUpload.PostedFile.FileName);
                    var extension   = Path.GetExtension(fileName);
                    var sizeInBytes = filePcUpload.PostedFile.ContentLength;
                    var user        = UserManager.GetUser();
                    var isPublic    = txtVisibility.Value == "1";

                    var newName = txtNewName.Text.Trim();
                    if (newName.Length > 0)
                    {
                        fileName = newName;
                    }

                    var newFile = new UploadedFile
                    {
                        Comment        = txtRemoteComment.Text,
                        Extension      = extension,
                        Filename       = fileName,
                        Downloaded     = 0,
                        FileSize       = sizeInBytes,
                        LastDownload   = null,
                        UploadDate     = DateTime.Now.ToUniversalTime(),
                        UserId         = (user != null) ? user.UserID : (int?)null,
                        UploadedFileID = 0,
                        IsPublic       = isPublic
                    };

                    try
                    {
                        db.Files.Add(newFile);
                        db.SaveChanges();

                        var filePath = UploadedFileManager.MapToPhysicalPath(newFile);
                        filePcUpload.PostedFile.SaveAs(filePath);

                        Response.Redirect("file.aspx?id=" + newFile.UploadedFileID);
                    }
                    catch (ThreadAbortException ex)
                    {
                    }
                    catch (Exception ex)
                    {
                        if (newFile.UploadedFileID > 0)
                        {
                            db.Files.Remove(newFile);

                            db.SaveChanges();
                        }

                        AddError("An unhandled error occured.");
                        AddError(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                AddError(ex.Message);
            }
        }
        public void ProcessRequest(HttpContext context)
        {
            var request  = context.Request;
            var response = context.Response;

            // Accepting user request
            var idStr = request.QueryString["id"];

            try
            {
                int id;
                if (!int.TryParse(idStr, out id))
                {
                    InvalidRequest(context, "Invalid request!");
                    return;
                }
                UploadedFile uploadedFile;
                using (var db = new UploadDb())
                {
                    db.Configuration.AutoDetectChangesEnabled = false;
                    db.Configuration.ProxyCreationEnabled     = false;

                    var file = db.Files.FirstOrDefault(a => a.UploadedFileID == id);
                    if (file == null)
                    {
                        InvalidRequest(context, "File does not exists!");
                        response.StatusCode = 404;
                        return;
                    }
                    uploadedFile = file;
                }

                //SiteException.LogException(new Exception(
                //	string.Format("UploadedFileID:{0}, IsPublic:{1}, UploadDate:{2}, Filename:{3}",
                //		uploadedFile.UploadedFileID,
                //		uploadedFile.IsPublic,
                //		uploadedFile.UploadDate,
                //		uploadedFile.Filename)));

                if (uploadedFile.IsPublic == false)
                {
                    // check the owner
                    var user = UserManager.GetUser();
                    if (user == null)
                    {
                        var succeed = UserManager.BasicAuthorize(context);
                        if (!succeed)
                        {
                            return;
                        }
                        user = UserManager.GetUser();
                    }

                    // not the file owner!
                    if (user == null || user.UserID != uploadedFile.UserId)
                    {
                        context.Response.Clear();
                        context.Response.Write("You do not have access to download this file!");
                        context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
                        context.Response.Flush();
                        context.Response.End();
                        return;
                    }
                }

                // file path
                var fileName = UploadedFileManager.MapToPhysicalPath(uploadedFile);

                // reading file info
                var fileInfo   = new FileInfo(fileName);
                var fileLength = fileInfo.Length;

                // Download information class
                using (var downloadInfo = new DownloadDataInfo(fileName))
                {
                    downloadInfo.DisplayFileName = UploadedFileManager.GetUrlFileName(uploadedFile);

                    // Reading request download range
                    var requestedRanges = HeadersParser.ParseHttpRequestHeaderMultipleRange(context.Request, fileLength);

                    // apply the ranges to the download info
                    downloadInfo.InitializeRanges(requestedRanges);

                    string etagMatched;
                    int    outcomeStausCode = 200;

                    // validating the ranges specified
                    if (!HeadersParser.ValidatePartialRequest(context.Request, downloadInfo, out etagMatched, ref outcomeStausCode))
                    {
                        // the request is invalid, this is the invalid code
                        context.Response.StatusCode = outcomeStausCode;

                        // show to the client what is the real ETag
                        if (!string.IsNullOrEmpty(etagMatched))
                        {
                            context.Response.AppendHeader("ETag", etagMatched);
                        }

                        // stop the preoccess
                        // but don't hassle with error messages
                        return;
                    }

                    // user ID, or IP or anything you use to identify the user
                    //var userIP = context.Request.UserHostAddress;

                    // Option 1: limiting the download speed for this file for this user!
                    //UserSpeedLimitManager.StartNewDownload(downloadInfo, userIP, DownloadLimit);

                    // Option 2: Limiting only this connection
                    downloadInfo.LimitTransferSpeed(DownloadLimit);

                    // It is very important to destory the DownloadProcess object
                    // Here the using block does it for us.
                    using (var process = new DownloadProcess(downloadInfo))
                    {
                        var state = DownloadProcess.DownloadProcessState.None;
                        try
                        {
                            // start the download
                            state = process.ProcessDownload(context.Response);
                        }
                        catch (HttpException)
                        {
                            // preventing:
                            // System.Web.HttpException (0x800703E3): The remote host closed the connection. The error code is 0x800703E3.
                        }

                        // checking the state of the download
                        if (state == DownloadProcess.DownloadProcessState.LastPartfinished)
                        {
                            // all parts of download are finish, do something here!
                            using (var db = new UploadDb())
                            {
                                var dbFile = db.Files.FirstOrDefault(a => a.UploadedFileID == uploadedFile.UploadedFileID);
                                if (dbFile != null)
                                {
                                    dbFile.Downloaded++;
                                    dbFile.LastDownload = DateTime.Now.ToUniversalTime();
                                    db.SaveChanges();
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                SiteException.LogException(ex, "ID: " + idStr);
                throw;
            }
        }
示例#3
0
        protected void rptRepeat_ItemCommand(object source, RepeaterCommandEventArgs e)
        {
            if (e.CommandName == "Delete")
            {
                var idString = e.CommandArgument.ToString();
                int id;
                if (!int.TryParse(idString, out id))
                {
                    return;
                }

                using (var db = new UploadDb())
                {
                    var file = db.Files.FirstOrDefault(a => a.UploadedFileID == id);
                    if (file == null)
                    {
                        Response.Write("File not found!");
                        Response.StatusCode = 404;
                        return;
                    }
                    var user = UserManager.GetUser();
                    if (user == null || (user.UserID != file.UserId && !user.IsAdmin))
                    {
                        Response.Write("You do not have the permission to delete!");
                        Response.StatusCode = 500;
                        return;
                    }
                    if (file.UserId == null && !user.IsAdmin)
                    {
                        Response.Write("You do not have the permission to delete!");
                        Response.StatusCode = 500;
                        return;
                    }

                    var fileAddress = UploadedFileManager.MapToPhysicalPath(file);
                    try
                    {
                        System.IO.File.Delete(fileAddress);

                        db.Files.Remove(file);
                        db.SaveChanges();
                        if (RedirectAfterDelete)
                        {
                            Response.Redirect(RedirectAfterDeleteLocation);
                        }
                        else
                        {
                            var notDisplayFile = Files.FirstOrDefault(a => a.UploadedFileID == file.UploadedFileID);
                            if (notDisplayFile != null)
                            {
                                Files.Remove(notDisplayFile);
                            }

                            ReloadFilesList();
                        }
                    }
                    catch (Exception ex)
                    {
                        AddError(ex.Message);
                    }
                }
            }
        }
        protected void btnRemoteUpload_Click(object sender, EventArgs e)
        {
            try
            {
                var url = txtRemoteUrl.Text.Trim();
                Uri uri;
                if (string.IsNullOrWhiteSpace(url) || !Uri.TryCreate(url, UriKind.Absolute, out uri))
                {
                    AddError("Please enter a valid Url!");
                    return;
                }

                var fileName = Path.GetFileName(url);
                var newName  = txtNewName.Text.Trim();
                if (newName.Length > 0)
                {
                    fileName = newName;
                }

                var referer = txtReferrer.Text.Trim();

                // temporary file name
                var  fileTempAddress = UploadedFileManager.MapToPhysicalPath(fileName + Guid.NewGuid().ToString());
                long sizeInBytes     = 0;

                var cookies = Deserialize(txtCookies.Value);
                try
                {
                    using (var file = new FileStream(fileTempAddress, FileMode.Create))
                    {
                        Download(uri, referer, cookies, file);
                        sizeInBytes = file.Length;
                    }
                }
                catch (Exception)
                {
                    System.IO.File.Delete(fileTempAddress);
                    throw;
                }

                // done!
                using (var db = new UploadDb())
                {
                    var extension = Path.GetExtension(fileName);
                    var user      = UserManager.GetUser();
                    var isPublic  = txtVisibility.Value == "1";

                    var newFile = new UploadedFile
                    {
                        Comment        = txtRemoteComment.Text,
                        Extension      = extension,
                        Filename       = fileName,
                        Downloaded     = 0,
                        FileSize       = sizeInBytes,
                        LastDownload   = null,
                        UploadDate     = DateTime.Now.ToUniversalTime(),
                        UserId         = (user != null) ? user.UserID : (int?)null,
                        UploadedFileID = 0,
                        IsPublic       = isPublic
                    };

                    try
                    {
                        db.Files.Add(newFile);
                        db.SaveChanges();

                        var filePath = UploadedFileManager.MapToPhysicalPath(newFile);
                        System.IO.File.Move(fileTempAddress, filePath);

                        Response.Redirect("file.aspx?id=" + newFile.UploadedFileID);
                    }
                    catch (ThreadAbortException ex)
                    {
                    }
                    catch (Exception ex)
                    {
                        if (newFile.UploadedFileID > 0)
                        {
                            db.Files.Remove(newFile);

                            db.SaveChanges();
                        }
                        try
                        {
                            System.IO.File.Delete(fileTempAddress);
                        }
                        catch { }

                        AddError("An unhandled error occured.");
                        AddError(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                AddError(ex.Message);
            }
        }