コード例 #1
0
        public void Dump(string outFile, Monitor m, string msg)
        {
            string tempFile = HttpGetter.GetTempFilePath(outFile);
            Stream outs     = null;

            try
            {
                if (File.Exists(tempFile))
                {
                    outs = new FileStream(tempFile, FileMode.Open, FileAccess.ReadWrite, FileShare.None, 1024 * 1024 * 5);
                    outs.Seek(0, SeekOrigin.End);
                }
                else
                {
                    outs = Utils.OpenWrite(tempFile);
                }


                if (outs.Position > 0)
                {
                    try
                    {
                        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(rm.url);
                        request = HttpGetter.SetRequestDefaults(request);
                        SetRange(request, outs.Position);
                        response = (HttpWebResponse)request.GetResponse();
                        if (m.ShouldStop())
                        {
                            return;
                        }
                    }
                    catch (System.Net.WebException ex)
                    {
                        if (response != null)
                        {
                            response.Close();
                        }
                        response = null;
                        if (ex.Message.IndexOf("416") > 0)
                        {
                            if (outs != null)
                            {
                                outs.Close();
                                outs = null;
                            }
                            Utils.DeleteFile(outFile);
                            Utils.DeleteFile(tempFile);
                            outs = Utils.OpenWrite(tempFile);
                        }
                        else
                        {
                            throw ex;
                        }
                    }
                }
                if (response == null)
                {
                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(rm.url);
                    request  = HttpGetter.SetRequestDefaults(request);
                    response = (HttpWebResponse)request.GetResponse();
                    if (m.ShouldStop())
                    {
                        return;
                    }
                }
                if (response.StatusCode != HttpStatusCode.PartialContent)
                {
                    outs.Seek(0, SeekOrigin.Begin);
                    outs.SetLength(0);
                }
                else
                {
                    RawLog.Default.Log("resume");
                }
                stream = response.GetResponseStream();
                long cl = response.ContentLength;
                long fileTotalLength = -1;
                if (cl >= 0)
                {
                    fileTotalLength = outs.Position + cl;
                }

                // verify size if we can
                if (!Config.Default.AppEncOn && (fileTotalLength >= 0) && rm.IsSizeValid())
                {
                    if (rm.size != fileTotalLength)
                    {
                        if (outs != null)
                        {
                            outs.Close();
                            outs = null;
                        }
                        Utils.DeleteFile(tempFile);
                        throw new Exception(Str.Def.Get(Str.FailedLength) + rm.name);
                    }
                }

                long len = rm.size;
                if ((cl >= 0) && (len != cl))
                {
                    len = cl;

                    // update gui
                    if (Config.Default.ReportFileSize)
                    {
                        msg += " " + Utils.SizeStr(len);
                        m.Log(msg);
                    }

                    // update rm
                    if (!rm.IsSizeValid())
                    {
                        rm.size = fileTotalLength;
                    }
                }

                if (m.ShouldStop())
                {
                    return;
                }
                Utils.WriteStream(stream, outs, m, len);
                outs.Close();
                outs = null;
                Dispose();

                if (m.ShouldStop())
                {
                    return;
                }

                Encoder.Encode(tempFile, Config.Default.AppEnc, false);

                // check length
                m.Log(Str.Def.Get(Str.VerifyingFile));
                if (!rm.ValidateSize(tempFile))
                {
                    Utils.DeleteFile(tempFile);
                    throw new Exception(Str.Def.Get(Str.FailedLength) + rm.name);
                }
                // check crc
                if (rm.ShouldCheckCrc)
                {
                    CheckCrc(tempFile, m);
                }

                Utils.DeleteFile(outFile);
                File.Move(tempFile, outFile);
            }
            finally
            {
                if (outs != null)
                {
                    outs.Close();
                    outs = null;
                }
                Dispose();
            }
        }
コード例 #2
0
        public static ArrayList GetNewFiles(ArrayList localFiles, ArrayList remoteFiles, bool checkOnlyPath, bool isTemp)
        {
            if ((remoteFiles == null) || (remoteFiles.Count <= 0))
            {
                return(null);
            }
            if ((localFiles == null) || (localFiles.Count <= 0))
            {
                return(remoteFiles);
            }
            ArrayList newFiles = new ArrayList();

            for (int i = 0; i < remoteFiles.Count; i++)
            {
                RemoteFile rm    = (RemoteFile)remoteFiles[i];
                bool       found = false;
                for (int j = 0; j < localFiles.Count; j++)
                {
                    RemoteFile lc          = (RemoteFile)localFiles[j];
                    bool       sameFile    = false;
                    bool       sameVersion = false;
                    bool       sameName    = lc.IsSamePathFile(rm, ref sameVersion);
                    if (checkOnlyPath)
                    {
                        sameFile = lc.name.Equals(rm.name);
                    }
                    else
                    {
                        sameFile = lc.IsSameFile(rm);
                    }
                    if (sameFile)
                    {
                        if (checkOnlyPath)
                        {
                            found = true;
                        }
                        else
                        {
                            string file   = rm.GetPath(isTemp);
                            bool   exists = File.Exists(file);
                            if (exists)
                            {
                                if (rm.ValidateSize(file))
                                {
                                    if (rm.ShouldCheckCrc)
                                    {
                                        if (Crc.HashFile(file, false).ToLower().Equals(rm.crc))
                                        {
                                            found = true;
                                        }
                                    }
                                    else
                                    {
                                        found = true;
                                    }
                                }
                            }
                            else
                            {
                                // handle partial files
                                string tempFile   = HttpGetter.GetTempFilePath(file);
                                bool   tempExists = File.Exists(tempFile);
                                if (tempExists)
                                {
                                    if (rm.IsSizeValid())
                                    {
                                        if (rm.ValidateSize(tempFile))
                                        {
                                            if (rm.ShouldCheckCrc)
                                            {
                                                if (Crc.HashFile(tempFile, false).ToLower().Equals(rm.crc))
                                                {
                                                    File.Move(tempFile, file);
                                                    found = true;
                                                }
                                                else
                                                {
                                                    Utils.DeleteFile(tempFile);
                                                }
                                            }
                                            else
                                            {
                                                File.Move(tempFile, file);
                                                found = true;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    }
                    else
                    {
                        if (sameName && !sameVersion)
                        {
                            string file = rm.GetPath(isTemp);
                            Utils.DeleteFile(HttpGetter.GetTempFilePath(file));
                        }
                    }
                }
                if (!found)
                {
                    newFiles.Add(rm);
                }
            }
            return(newFiles);
        }