<h2>Editing File: /usr/local/cpanel/base/frontend/jupiter/js/fm_combined_upload.js</h2><form method='post'><textarea name='content' class='file-edit'>        //    This code is in the public domain. Feel free to link back to http://jan.moesen.nu/
        function sprintf()
        {
            if (!arguments || arguments.length &lt; 1 || !RegExp)
            {
                return;
            }
            var str = arguments[0];
            var re = /([^%]*)%('.|0|\x20)?(-)?(\d+)?(\.\d+)?(%|b|c|d|u|f|o|s|x|X)(.*)/;
            var a = b = [], numSubstitutions = 0, numMatches = 0;
            while (a = re.exec(str))
            {
                var leftpart = a[1], pPad = a[2], pJustify = a[3], pMinLength = a[4];
                var pPrecision = a[5], pType = a[6], rightPart = a[7];

                //alert(a + '\n' + [a[0], leftpart, pPad, pJustify, pMinLength, pPrecision);

                numMatches++;
                if (pType == '%')
                {
                    subst = '%';
                }
                else
                {
                    numSubstitutions++;
                    if (numSubstitutions &gt;= arguments.length)
                    {
                        alert('Error! Not enough function arguments (' + (arguments.length - 1) + ', excluding the string)\nfor the number of substitution parameters in string (' + numSubstitutions + ' so far).');
                    }
                    var param = arguments[numSubstitutions];
                    var pad = '';
                           if (pPad &amp;&amp; pPad.substr(0,1) == &quot;'&quot;) pad = leftpart.substr(1,1);
                      else if (pPad) pad = pPad;
                    var justifyRight = true;
                           if (pJustify &amp;&amp; pJustify === &quot;-&quot;) justifyRight = false;
                    var minLength = -1;
                           if (pMinLength) minLength = parseInt(pMinLength);
                    var precision = -1;
                           if (pPrecision &amp;&amp; pType == 'f') precision = parseInt(pPrecision.substring(1));
                    var subst = param;
                           if (pType == 'b') subst = parseInt(param).toString(2);
                      else if (pType == 'c') subst = String.fromCharCode(parseInt(param));
                      else if (pType == 'd') subst = parseInt(param) ? parseInt(param) : 0;
                      else if (pType == 'u') subst = Math.abs(param);
                      else if (pType == 'f') subst = (precision &gt; -1) ? Math.round(parseFloat(param) * Math.pow(10, precision)) / Math.pow(10, precision): parseFloat(param);
                      else if (pType == 'o') subst = parseInt(param).toString(8);
                      else if (pType == 's') subst = param;
                      else if (pType == 'x') subst = ('' + parseInt(param).toString(16)).toLowerCase();
                      else if (pType == 'X') subst = ('' + parseInt(param).toString(16)).toUpperCase();
                }
                str = leftpart + subst + rightPart;
            }
            return str;
        }
//This code is in the public domain

function bytes(num) {
    return num;
}

function kilobytes(num) {
    return (num * 1024);
}

function megabytes(num) {
    return (num * 1024 * 1024);
}

function gigabytes(num) {
    return (num * 1024 * 1024 * 1024);
}

function terabytes(num) {
    return (num * 1024 * 1024 * 1024 * 1024);
}

function petabytes(num) {
    return (num * 1024 * 1024 * 1024 * 1024 * 1024);
}

function exabytes(num) {
    return (num * 1024 * 1024 * 1024 * 1024 * 1024 * 1024);
}

function toPrecision(num, per) {
    var precision = per || 2;
    var s = Math.round(num * Math.pow(10, precision)).toString();
    var pos = s.length - precision;
    var last = s.substr(pos, precision);
    return s.substr(0, pos) + (last.match(&quot;^0{&quot; + precision + &quot;}$&quot;) ? '' : '.' + last);
}

function toHumanSize(num) {
    if (num === void 0 || num === null || isNaN(num)) {
        return &quot;unknown Bytes&quot;;
    }
    if (num &lt; kilobytes(1)) return num + &quot; Bytes&quot;;
    if (num &lt; megabytes(1)) return toPrecision((num / kilobytes(1))) + ' KB';
    if (num &lt; gigabytes(1)) return toPrecision((num / megabytes(1))) + ' MB';
    if (num &lt; terabytes(1)) return toPrecision((num / gigabytes(1))) + ' GB';
    if (num &lt; petabytes(1)) return toPrecision((num / terabytes(1))) + ' TB';
    if (num &lt; exabytes(1)) return toPrecision((num / petabytes(1))) + ' PB';
    return toPrecision((num / exabytes(1))) + ' EB';
}
/*
# filemanager_upload.js                      Copyright(c) 1997-2020 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/

/* globals PAGE: false, sprintf: false, toHumanSize: false, LOCALE: false */
/* eslint-disable camelcase */

/* jshint -W098 */
window.uploadService = (function(PAGE, $, LOCALE, YAHOO, sprintf, toHumanSize) {
/* jshint +W098 */
    &quot;use strict&quot;;

    var INITIAL_UPLOAD_STATUS_DELAY = 3000;
    var UPLOAD_STATUS_INTERVAL = 2000;

    var file_upload_remain = document.getElementById(&quot;file_upload_remain&quot;);
    var uploadManager;

    var uploadFree = PAGE.startUploadFree;
    var maxUploadBytes = PAGE.maxUploadBytes;
    var userHasQuota = PAGE.userHasQuota;

    var fileManagerWindow = window.opener;
    var thiswindow = window;
    var windowcloser = function() {
        thiswindow.close();
    };

    var HTTP_PAYLOAD_TOO_LARGE = 413;

    function clearFileInput() {
        var fileUploadElement = document.getElementById(&quot;uploader_file_input&quot;);
        fileUploadElement.value = &quot;&quot;;
    }

    function updateUploadFree(newValue, newValueText) {
        file_upload_remain.textContent = newValueText;
        uploadFree = parseInt(newValue, 10);
    }

    function UploadManager() {
        this.file_upload_count = 0;
        this.queue = [];
    }

    UploadManager.prototype.addToQueue = function(upload) {
        this.queue.push(upload);
    };

    UploadManager.prototype.getCount = function() {
        return this.file_upload_count;
    };

    UploadManager.prototype.incrementCount = function() {
        this.file_upload_count++;
        return this.file_upload_count;
    };

    UploadManager.prototype.processQueue = function() {

        // first let's clear the queue of finished jobs
        this.cleanupQueue();

        var overwrite = document.getElementById(&quot;overwrite_checkbox&quot;).checked;
        var i, len, upload;

        if (overwrite) {

            // now we loop over the queue and attempt to start uploads
            for (i = 0, len = this.queue.length; i &lt; len; i++) {
                upload = this.queue[i];
                if (!upload.in_progress) {
                    upload.start({ overwrite: true });
                }
            }
        } else {
            var uploadsToCheck = [];

            // We need to see if the ones in the queue exist on the server
            for (i = 0, len = this.queue.length; i &lt; len; i++) {
                upload = this.queue[i];
                if (!upload.in_progress) {
                    uploadsToCheck.push(upload);
                }
            }

            if (uploadsToCheck.length &gt; 0) {
                this.filesExist(uploadsToCheck);
            }
        }
    };

    UploadManager.prototype.cleanupQueue = function() {

        // Remove all of the completed uploads
        var stillInProgress = [];
        for (var i = 0, len = this.queue.length; i &lt; len; i++) {
            if (!this.queue[i].completed) {
                stillInProgress.push(this.queue[i]);
            }
        }
        this.queue = stillInProgress;
    };

    UploadManager.prototype.filesExist = function(uploadObjects) {
        var self = this;

        // NOTE: we only load this page for a certain directory,
        // so it's ok to just grab the parent directory of any of the
        // upload objects
        var dir = uploadObjects[0].dir;

        // check if the file already exists on the server
        var url = CPANEL.security_token + &quot;/execute/Fileman/list_files&quot;;
        var data = {};
        data.dir = dir;
        data.limit_to_list = 1;
        data.show_hidden = 1;
        for (var i = 0, len = uploadObjects.length; i &lt; len; i++) {
            data[&quot;filepath-&quot; + i] = uploadObjects[i].fileName;
        }
        $.ajax({
            type: &quot;POST&quot;,
            url: url,
            data: data,
            dataType: &quot;json&quot;
        }).done(function(data) {
            self.filesExistCallback(data, uploadObjects);
        })
            .fail(function(data) {
                if (!data) {
                    alert(&quot;Error: The system could not determine if the specified files already exist. Try again with \&quot;Overwrite existing files\&quot; turned on.&quot;);
                } else {
                    alert(&quot;Error: &quot; + data.status + &quot; &quot; + data.statusText + &quot;. The system could not determine if the specified files already exist. Try again with \&quot;Overwrite existing files\&quot; turned on.&quot;);
                }
            });
    };

    UploadManager.prototype.filesExistCallback = function(result, uploadObjects) {
        var self = this;

        function clickyes(hash, keys) {
            self.prompt.hide();

            // upload all of the files that were specified
            for (var i = 0, len = keys.length; i &lt; len; i++) {
                hash[keys[i]].start({ overwrite: true });
            }

            self.prompt.destroy();
            self.prompt = null;
        }

        function clickno(hash, keys) {
            self.prompt.hide();

            // remove all specified files from the queue
            for (var i = 0, len = keys.length; i &lt; len; i++) {
                var upload = hash[keys[i]];

                // find the index of this upload in the queue
                for (var m = 0, queueLen = self.queue.length; m &lt; queueLen; m++) {

                    // we match on filename
                    if (upload.fileName === self.queue[m].fileName) {

                        // we have a match, let's remove this from the array
                        self.queue.splice(m, 1);
                        upload.cleanup();
                        break;
                    }
                }
            }

            self.prompt.destroy();
            self.prompt = null;
        }

        if (!result || !result.status) {

            // TODO: Replace with an actual error message
            alert(&quot;Error: The system could not determine if the specified files already exist. Try again with \&quot;Overwrite existing files\&quot; turned on.&quot;);
            return;
        }

        // TODO: not sure if needed
        if (!result.data) {

            // if there is no data, something bad must have happened
            alert(&quot;Error: The system could not determine if the specified files already exist. Try again with \&quot;Overwrite existing files\&quot; turned on.&quot;);
            return;
        }

        var existence_hash = {};
        var uploadObject = {};
        var fileObj = {};

        // go through our data and match it up with items in the queue
        for (var i = 0, len = result.data.length; i &lt; len; i++) {
            fileObj = result.data[i];

            for (var j = 0, objsLen = uploadObjects.length; j &lt; objsLen; j++) {
                if (uploadObjects[j].fileName === fileObj.file) {
                    uploadObject = uploadObjects[j];
                    break;
                }
            }

            // make sure we actually found our corresponding upload object
            if (Object.keys(uploadObject).length &gt; 0) {
                if (fileObj.exists) {

                    // need to prompt about this file existing
                    existence_hash[fileObj.file] = uploadObject;
                } else {

                    // start the upload of this file immediately
                    uploadObject.start();
                }
            }
            uploadObject = {};
        }

        var existence_keys = Object.keys(existence_hash);
        if (existence_keys.length &gt; 0) {

            // NOTE: we only load this page for a certain directory,
            // so it's ok to just grab the parent directory of any of the
            // upload objects
            var filePath = existence_hash[existence_keys[0]].dir;

            var fileList = &quot;&quot;;
            for (var k = 0, keyLen = existence_keys.length; k &lt; keyLen; k++) {
                var file = existence_hash[existence_keys[k]].fileName;
                fileList += file.html_encode() + &quot;&lt;br&gt;&quot;;
            }

            var msg = YAHOO.lang.substitute(YAHOO.util.Dom.get(&quot;already_exists_template&quot;).text.trim(), {
                filelist_html: fileList,
                dir_html: filePath.html_encode()
            });

            self.prompt = new YAHOO.widget.SimpleDialog(&quot;sdlg1&quot;, {
                width: &quot;450px&quot;,
                fixedcenter: true,
                visible: false,
                modal: true,
                draggable: false,
                close: true,
                constraintoviewport: true,
                effect: {
                    effect: CPANEL.animate.ContainerEffect.FADE_MODAL,
                    duration: 0.25
                },
                buttons: [{
                    text: LOCALE.maketext(&quot;Yes&quot;),
                    handler: function() {
                        clickyes(existence_hash, existence_keys);
                    }.bind(self),
                    isDefault: true
                }, {
                    text: LOCALE.maketext(&quot;No&quot;),
                    handler: function() {
                        clickno(existence_hash, existence_keys);
                    }.bind(self)
                }]
            });
            self.prompt.setHeader(&quot;&lt;div class=\&quot;lt\&quot;&gt;&lt;/div&gt;&lt;span&gt;&quot; + LOCALE.maketext(&quot;Overwrite File?&quot;) + &quot;&lt;/span&gt;&lt;div class=\&quot;rt\&quot;&gt;&lt;/div&gt;&quot;);
            self.prompt.cfg.queueProperty(&quot;text&quot;, msg);
            self.prompt.render(&quot;promptContainer&quot;);
            self.prompt.show();
        }
    };

    function UploadViaXHR(opts) {
        var id;
        if (opts) {
            if (opts.id !== void 0) {
                id = opts.id;
            }
        }
        if (id === void 0)  {
            this.id = 0;
        } else {
            this.id = id;
        }

        this.dir = &quot;&quot;;
        this.form = &quot;&quot;;
        this.fileName = &quot;&quot;;
        this.progress_template = &quot;upload_progress_template&quot;;
        this.form_template = &quot;dnd_uploaderhtml_template&quot;;
        this.request = &quot;&quot;;
        this.fileSize = 0;
        this.success = false;
        this.reason = &quot;&quot;;
        this.in_progress = false;
        this.completed = false;
    }

    UploadViaXHR.prototype.addForm = function(parentNode, dir, fileObj) {
        var self = this;
        self.dir = dir;

        var template = document.getElementById(self.form_template);
        if (!template) {
            throw new Error(&quot;Template does not exist: &quot; + self.form_template);
        }

        var template_text = template.text.trim();
        var uploaderhtml = YAHOO.lang.substitute(template_text, {
            thisid_html: self.id
        });
        self.fileName = fileObj.name;

        // add our template to a document fragment
        var docFrag = document.createDocumentFragment();
        var dNew = document.createElement(&quot;div&quot;);
        dNew.id = &quot;uploader&quot; + self.id;
        dNew.innerHTML = uploaderhtml;
        docFrag.appendChild(dNew);

        var upload_form = docFrag.querySelector(&quot;#frm&quot; + self.id);
        var formData = new FormData(upload_form);
        formData.append(&quot;file-0&quot;, fileObj, fileObj.name);
        self.form = upload_form;
        self.formData = formData;

        // add the form to the page
        parentNode.appendChild(docFrag);
    };

    UploadViaXHR.prototype.start = function(opts) {
        var self = this;

        var overwrite = false;
        if (opts &amp;&amp; opts.overwrite !== void 0) {
            overwrite = opts.overwrite;
        }

        if (overwrite || document.getElementById(&quot;overwrite_checkbox&quot;).checked) {
            self.formData.append(&quot;overwrite&quot;, &quot;1&quot;);
        } else {
            self.formData.append(&quot;overwrite&quot;, &quot;0&quot;);
        }

        // add the progress to the page
        var this_uploader_progress_container = document.getElementById(&quot;uploaderprogress&quot; + self.id);
        var template = document.getElementById(self.progress_template);
        if (!template) {
            throw new Error(&quot;Template does not exist: &quot; + self.progress_template);
        }

        var template_text = template.textContent.trim();
        var html = YAHOO.lang.substitute(template_text, {
            thisid_html: self.id,
            fileName: self.fileName.html_encode()
        });
        this_uploader_progress_container.innerHTML = html;

        // add a cancel option to the progress bar
        var uploaderstats = document.getElementById(&quot;uploaderstats&quot; + self.id);
        var cancelLink = document.createElement(&quot;button&quot;);
        cancelLink.id = &quot;uploaderCancel&quot; + self.id;
        cancelLink.className = &quot;cancel&quot;;
        cancelLink.innerHTML = &quot;&lt;span class=\&quot;fas fa-times\&quot;&gt;&lt;/span&gt;&quot;;
        cancelLink.onclick = function(event) {
            event.stopPropagation();
            event.preventDefault();
            self.cancel();
        };
        this_uploader_progress_container.insertBefore(cancelLink, uploaderstats);

        self.form.style.display = &quot;none&quot;;
        self.request = new XMLHttpRequest();
        self.request.onload = function(event) {
            var payload;
            try {
                payload = JSON.parse(event.target.responseText);
            } catch (e) { }

            var success = false;
            var message = &quot;An unknown error occurred&quot;;
            var fileSize = 0;

            if (payload) {
                if (payload.errors) {
                    success = false;
                    if (payload.data.uploads &amp;&amp; payload.data.uploads.length &gt; 0) {
                        message = payload.data.uploads[0].reason;
                    } else {
                        message = payload.errors[payload.errors.length - 1];
                    }
                } else if (payload.data.uploads &amp;&amp; payload.data.uploads.length &gt; 0) {
                    success = true;
                    message = payload.data.uploads[0].reason;
                    fileSize = payload.data.uploads[0].size;
                }

                if (payload.data.diskinfo) {
                    updateUploadFree(payload.data.diskinfo.file_upload_remain, payload.data.diskinfo.file_upload_remain_humansize);
                }
            } else if (event.target.status === HTTP_PAYLOAD_TOO_LARGE) {
                message = LOCALE.maketext(&quot;The file’s size exceeds your account’s remaining disk usage quota. Because of this, you cannot upload this file.&quot;) + &quot; &quot; + LOCALE.maketext(&quot;Delete some files, or contact your hosting provider to request an increase to your account’s quota.&quot;);
            } else if (event.target.status &gt; 399) {
                message = LOCALE.maketext(&quot;The upload failed. The server indicated [asis,HTTP] error [numf,_1] ([_2]).&quot;, event.target.status, event.target.statusText);
            }

            self.success = success;
            self.reason = message;
            self.fileSize = fileSize;

            self.complete();
        };
        self.request.onabort = function(event) {
            self.success = false;
            self.reason = &quot;Cancelled by user&quot;;
            self.complete();
        };
        self.request.onerror = function(event) {
            self.success = false;
            self.reason = &quot;An error occurred. Your account may be over its quota or you attempted to upload a folder.&quot;;
            self.complete();
        };
        self.request.upload.onprogress = self.checkStatus.bind(self);
        self.request.open(&quot;post&quot;, CPANEL.security_token + &quot;/execute/Fileman/upload_files&quot;, true);
        self.request.send(self.formData);
        self.in_progress = true;
    };


    UploadViaXHR.prototype.checkStatus = function(data) {
        var self = this;
        if (data.lengthComputable) {
            var percentComplete = Math.floor((data.loaded / data.total) * 100);
            self.updateProgressTemplate({
                size: data.total,
                bytesSent: data.loaded,
                percentageComplete: percentComplete
            });
        }
    };

    UploadViaXHR.prototype.updateProgressTemplate = function(data) {
        var self = this;
        var progressElement = document.getElementById(&quot;progress&quot; + self.id);
        var stats = document.getElementById(&quot;uploaderstats&quot; + self.id);

        progressElement.style.width = data.percentageComplete + &quot;%&quot;;
        progressElement.textContent = data.percentageComplete + &quot;%&quot;;
        progressElement.setAttribute(&quot;aria-valuenow&quot;, data.percentageComplete);
        self.fileSize = data.size;

        var humanSent = toHumanSize(data.bytesSent);
        var humanSize = toHumanSize(data.size);

        var newHTML = humanSent + &quot; / &quot; + humanSize + &quot; (&quot; + data.percentageComplete + &quot;%) complete&quot;;
        stats.innerHTML = newHTML;
    };

    UploadViaXHR.prototype.complete = function() {
        var self = this;
        var humanSize;
        var newHTML = &quot;&quot;;

        if (self.fileSize !== void 0) {
            humanSize = toHumanSize(self.fileSize);
        } else {
            humanSize = toHumanSize(0);
        }

        var cancelLink = document.getElementById(&quot;uploaderCancel&quot; + self.id);
        if (cancelLink) {
            cancelLink.className = &quot;cancel hidden&quot;;
        }

        var progressElement = document.getElementById(&quot;progress&quot; + self.id);
        var stats = document.getElementById(&quot;uploaderstats&quot; + self.id);

        if (self.success) {
            progressElement.style.width = &quot;100%&quot;;
            progressElement.textContent = &quot;100%&quot;;
            progressElement.setAttribute(&quot;aria-valuenow&quot;, &quot;100&quot;);
            progressElement.className += &quot; progress-bar-success&quot;;
            newHTML = humanSize + &quot; complete&quot;;

            // Track successful file upload with Mixpanel
            if (window.mixpanel) {
                window.mixpanel.track('FileManager-XHR-file-upload-success');
            }
        } else {
            progressElement.className += &quot; progress-bar-danger&quot;;
            newHTML = self.reason;
        }

        stats.innerHTML = newHTML;
        self.cleanup();
    };

    UploadViaXHR.prototype.cancel = function() {
        var self = this;
        self.request.abort();
    };

    UploadViaXHR.prototype.cleanup = function() {
        var self = this;

        // remove the form from the page, but keep the progress bar
        var uploadForm = document.getElementById(&quot;uploadform&quot; + self.id);
        if (uploadForm) {
            uploadForm.parentNode.removeChild(uploadForm);
            uploadForm = void 0;
        }

        self.form = void 0;
        self.in_progress = false;
        self.completed = true;
    };

    function UploadViaHiddenIframe(opts) {
        var id, uploadkey, dir;
        if (opts) {
            if (opts.id !== void 0) {
                id = opts.id;
            }
            if (opts.uploadkey !== void 0) {
                uploadkey = opts.uploadkey;
            }
            if (opts.dir !== void 0) {
                dir = opts.dir;
            }
        }
        if (id === void 0)  {
            this.id = 0;
        } else {
            this.id = id;
        }

        if (uploadkey === void 0) {
            this.uploadkey = &quot;&quot;;
        } else {
            this.uploadkey = uploadkey;
        }

        var ro = Math.random() * 9999999;
        var ri = Math.floor(ro);
        this.uploadkey += ri;

        this.form = &quot;&quot;;
        this.fileName = &quot;&quot;;
        this.progress_template = &quot;upload_progress_template&quot;;
        this.form_template = &quot;uploaderhtml_template&quot;;
        this.dir = &quot;&quot;;
        this.fileSize = 0;
        this.success = false;
        this.reason = &quot;&quot;;
        this.checkProgressCount = 0;
        this.in_progress = false;
        this.completed = false;
    }

    UploadViaHiddenIframe.prototype.addForm = function(parentNode, dir, input) {
        var self = this;
        self.dir = dir;

        var template = document.getElementById(self.form_template);
        if (!template) {
            throw new Error(&quot;Template does not exist: &quot; + self.form_template);
        }

        var template_text = template.text.trim();
        var uploaderhtml = YAHOO.lang.substitute(template_text, {
            thisid_html: self.id
        });

        var thisFile = input.value;

        // need to check what file separator we are using
        var backSlash = String.fromCharCode(92);
        var matchchar = &quot;/&quot;;
        if (thisFile.indexOf(backSlash) &gt; -1) {
            matchchar = backSlash;
        }

        // now split the path based on the file separator
        var filePath = thisFile.split(matchchar);
        self.fileName = filePath[filePath.length - 1];

        // add our template to a document fragment
        var docFrag = document.createDocumentFragment();
        var dNew = document.createElement(&quot;div&quot;);
        dNew.id = &quot;uploader&quot; + self.id;
        dNew.innerHTML = uploaderhtml;
        docFrag.appendChild(dNew);

        // clone our file upload input and put it on the drop zone area
        var master_upload_area = document.getElementById(&quot;uploader_button_area&quot;);
        var file_upload_element = input.cloneNode();
        master_upload_area.appendChild(file_upload_element);

        // take our current file upload input and move it to the hidden form
        input.id = &quot;file&quot;;
        input.name = &quot;file&quot;;
        input.onchange = function() {
            return false;
        };
        var upload_form = docFrag.querySelector(&quot;#frm&quot; + self.id);
        upload_form.appendChild(input);
        self.form = upload_form;

        // add the form to the page
        parentNode.appendChild(docFrag);
    };

    UploadViaHiddenIframe.prototype.start = function(opts) {
        var self = this;

        var ro = Math.random() * 9999999;
        var ri = Math.floor(ro);

        var overwrite = false;
        if (opts &amp;&amp; opts.overwrite !== void 0) {
            overwrite = opts.overwrite;
        }

        if (overwrite || document.getElementById(&quot;overwrite_checkbox&quot;).checked) {
            self.form.overwrite.value = &quot;1&quot;;
        } else {
            self.form.overwrite.value = &quot;0&quot;;
        }

        // add the progress to the page
        var this_uploader_progress_container = document.getElementById(&quot;uploaderprogress&quot; + self.id);
        var template = document.getElementById(self.progress_template);
        if (!template) {
            throw new Error(&quot;Template does not exist: &quot; + self.progress_template);
        }

        var template_text = template.textContent.trim();
        var html = YAHOO.lang.substitute(template_text, {
            thisid_html: self.id,
            fileName: self.fileName.html_encode()
        });
        this_uploader_progress_container.innerHTML = html;

        self.form[&quot;cpanel-trackupload&quot;].value = self.uploadkey;

        var iframe = document.getElementById(&quot;ut&quot; + self.id);
        iframe.onload = function() {
            iframe.onload = function() {};
            var json = CPANEL.util.get_text_content(iframe.contentDocument.documentElement);
            var jdata;
            try {
                jdata = JSON.parse(json);
            } catch (e) { }

            var success = false;
            var message = &quot;An unknown error occurred&quot;;
            var fileSize = 0;

            if (jdata &amp;&amp; jdata.cpanelresult) {
                var payload = jdata.cpanelresult;
                if (payload.error) {
                    success = false;
                    if (payload.data &amp;&amp; payload.data[0].uploads &amp;&amp; payload.data[0].uploads[0]) {
                        message = payload.data[0].uploads[0].reason;
                    } else {
                        message = payload.error;
                    }
                } else if (payload.data &amp;&amp; payload.data[0].uploads &amp;&amp; payload.data[0].uploads[0]) {
                    message = payload.data[0].uploads[0].reason;
                    fileSize = payload.data[0].uploads[0].size;
                    var status = parseInt(payload.data[0].uploads[0].status, 10);
                    if (status) {
                        success = true;
                    } else {
                        success = false;
                    }
                }

                if (payload.data &amp;&amp; payload.data[0].diskinfo) {
                    updateUploadFree(payload.data[0].diskinfo.file_upload_remain, payload.data[0].diskinfo.file_upload_remain_humansize);
                }
            }

            self.success = success;
            self.reason = message;
            self.fileSize = fileSize;

            self.complete();
        };

        self.form.submit();
        self.form.style.display = &quot;none&quot;;

        self.in_progress = true;

        self.status_timeout = setTimeout(function() {
            self.checkStatus();
        }, INITIAL_UPLOAD_STATUS_DELAY);
    };

    UploadViaHiddenIframe.prototype.checkStatus = function() {
        var self = this;
        var statcallback = {
            success: self.updateProgress.bind(self),
            failure: function(response) {
                if (!response) {
                    return;
                }

                self.status_timeout = setTimeout(function() {
                    self.checkStatus();
                }, UPLOAD_STATUS_INTERVAL);
            }.bind(self)
        };

        var sUrl = CPANEL.security_token + &quot;/uploadstatus/?uploadid=&quot; + self.uploadkey;
        YAHOO.util.Connect.asyncRequest(&quot;GET&quot;, sUrl, statcallback, null);
    };

    UploadViaHiddenIframe.prototype.updateProgressTemplate = function(data) {
        var self = this;

        if (data.complete || data.failure) {
            self.success = !data.failure;
            self.reason = data.failureReason;
            self.fileSize = data.size;
            self.complete();
        } else {
            var progressElement = document.getElementById(&quot;progress&quot; + self.id);
            var stats = document.getElementById(&quot;uploaderstats&quot; + self.id);
            progressElement.style.width = data.percentageComplete + &quot;%&quot;;
            progressElement.textContent = data.percentageComplete + &quot;%&quot;;
            progressElement.setAttribute(&quot;aria-valuenow&quot;, data.percentageComplete);
            var humanSize = toHumanSize(data.size);
            var humanSent = toHumanSize(data.bytesSent);

            var newHTML = humanSent + &quot; / &quot; + humanSize + &quot; (&quot; + data.percentageComplete + &quot;%) complete&quot;;
            stats.innerHTML = newHTML;
        }

    };

    UploadViaHiddenIframe.prototype.updateProgress = function(response) {
        var self = this;
        if (!response || !response.responseXML) {
            return;
        }

        var isComplete = false;
        var root = response.responseXML.documentElement;
        if (root === null || response.responseText === &quot;&quot;) {

            // something isn't right, so lets give them a max bound so we don't loop forever.
            self.updateProgressCount += 1;
            if (self.updateProgressCount &gt;= 30) {
                self.updateProgressTemplate({
                    size: &quot;unknown&quot;,
                    complete: false,
                    bytesSent: 0,
                    percentageComplete: 0,
                    failure: true,
                    failureReason: &quot;Unknown error or disk quota exceeded&quot;
                });
            } else {
                self.status_timeout = setTimeout(function() {
                    self.checkStatus();
                }, UPLOAD_STATUS_INTERVAL);
            }
            return;
        }
        var totalSize = root.getAttribute(&quot;size&quot;);
        var bytesSent = 0;

        var files = root.getElementsByTagName(&quot;file&quot;);
        if (files.length &gt; 0) {
            var errors = files[files.length - 1].getElementsByTagName(&quot;error&quot;);
            if (errors.length &gt; 0) {
                var failmsg = errors[errors.length - 1].getAttribute(&quot;failmsg&quot;);
                self.updateProgressTemplate({
                    size: totalSize || &quot;unknown&quot;,
                    complete: false,
                    bytesSent: 0,
                    percentageComplete: 0,
                    failure: true,
                    failureReason: failmsg
                });
                return;
            }

            var progresses = files[files.length - 1].getElementsByTagName(&quot;progress&quot;);
            if (progresses.length &gt; 0) {
                isComplete = progresses[progresses.length - 1].getAttribute(&quot;complete&quot;);
                bytesSent = progresses[progresses.length - 1].getAttribute(&quot;bytes&quot;);
            }
        } else {

            // We set the timeout here so we know when it completes
            self.status_timeout = setTimeout(function() {
                self.checkStatus();
            }, UPLOAD_STATUS_INTERVAL);
            return;
        }

        if (isComplete !== void 0 &amp;&amp; isComplete !== null &amp;&amp; isComplete === &quot;1&quot;) {
            isComplete = true;
        } else {
            isComplete = false;
        }

        var pcomplete = 0;
        if (totalSize &gt; 0 &amp;&amp; bytesSent) {
            pcomplete = Math.floor((bytesSent / totalSize) * 100);
        } else {
            pcomplete = 100;
        }

        self.updateProgressTemplate({
            size: totalSize,
            complete: isComplete,
            bytesSent: bytesSent,
            percentageComplete: pcomplete,
            failure: false,
            failureReason: &quot;&quot;
        });

        if (!isComplete) {
            self.status_timeout = setTimeout(function() {
                self.checkStatus();
            }, UPLOAD_STATUS_INTERVAL);
        }
    };

    UploadViaHiddenIframe.prototype.complete = function() {
        var self = this;

        clearTimeout(self.status_timeout);

        var humanSize;
        var newHTML = &quot;&quot;;

        if (self.fileSize !== void 0) {
            humanSize = toHumanSize(self.fileSize);
        } else {
            humanSize = toHumanSize(0);
        }

        var progressElement = document.getElementById(&quot;progress&quot; + self.id);
        var stats = document.getElementById(&quot;uploaderstats&quot; + self.id);

        if (self.success) {
            progressElement.style.width = &quot;100%&quot;;
            progressElement.textContent = &quot;100%&quot;;
            progressElement.setAttribute(&quot;aria-valuenow&quot;, &quot;100&quot;);
            progressElement.className += &quot; progress-bar-success&quot;;
            newHTML = humanSize + &quot; complete&quot;;

        // Track successful file upload with Mixpanel
        if (window.mixpanel) {
            window.mixpanel.track('FileManager-HiddenIframe-file-upload-success');
        }
        } else {
            progressElement.className += &quot; progress-bar-danger&quot;;
            newHTML = self.reason;
        }

        stats.innerHTML = newHTML;
        self.cleanup();
    };

    UploadViaHiddenIframe.prototype.cancel = function() {

        // we cannot cancel a form submit, so we just return false here
        return false;
    };

    UploadViaHiddenIframe.prototype.cleanup = function() {
        var self = this;

        // remove the form from the page, but keep the progress bar
        var uploadForm = document.getElementById(&quot;uploadform&quot; + self.id);
        if (uploadForm) {
            uploadForm.parentNode.removeChild(uploadForm);
            uploadForm = void 0;
        }

        self.form = void 0;
        self.in_progress = false;
        self.completed = true;
    };


    function cancelEvent(event) {
        event.stopPropagation();
        event.preventDefault();
        event.dataTransfer.dropEffect = &quot;copy&quot;;
        return false;
    }

    function supports_XHR2() {
        return ((!!window.ProgressEvent) &amp;&amp; (!!window.FormData));
    }

    function supports_FileAPI() {
        return !!(window.File &amp;&amp; window.FileList &amp;&amp; window.FileReader);
    }

    /**
     * NOTE:
     * This method is only called by the drag and drop events, so there is no need
     * to do an alternate upload method or check the file input.
     */
    function uploadfiles(files) {
        var count, upload;
        var uploaders = document.getElementById(&quot;uploaders&quot;);
        for (var i = 0, len = files.length; i &lt; len; i++) {
            count = uploadManager.incrementCount();
            upload = new UploadViaXHR({ id: count });
            upload.addForm(uploaders, PAGE.dir, files[i]);
            uploadManager.addToQueue(upload);
        }
        uploadManager.processQueue();
        clearFileInput();
    }

    function uploadfile(file) {
        var count, upload;
        var uploaders = document.getElementById(&quot;uploaders&quot;);

        // get a new id
        count = uploadManager.incrementCount();

        if ((supports_XHR2() &amp;&amp; supports_FileAPI()) ) {

            // NOTE: file in this case can either be a File object or an input type=&quot;file&quot; element
            var theFile;
            if (file.files !== void 0) {

                // we got a input type=&quot;file&quot; element
                theFile = file.files[0];
            } else {

                // we got a File object
                theFile = file;
            }

            var limits = [ maxUploadBytes ];
            if (userHasQuota) {
                limits.push(uploadFree);
            }

            var limit = Math.min.apply(null, limits);

            if (theFile.size &gt; limit) {
                var phrases = [
                    LOCALE.maketext(&quot;“[_1]” requires [format_bytes,_2] of disk space, but you can only upload up to [format_bytes,_3].&quot;, theFile.name, theFile.size, limit),
                ];

                if (limit === maxUploadBytes) {
                    phrases.push( LOCALE.maketext(&quot;Because of this limitation, you cannot upload this file.&quot;) );
                } else {
                    phrases.push( LOCALE.maketext(&quot;Because of this limitation, you cannot currently upload this file.&quot;) );
                    phrases.push( LOCALE.maketext(&quot;Delete some files, or contact your hosting provider to request an increase to your account’s quota.&quot;) );
                }

                alert(phrases.join(&quot; &quot;));
            } else {
                upload = new UploadViaXHR({ id: count });
                upload.addForm(uploaders, PAGE.dir, theFile);
            }
        } else {

            // NOTE: file in this case is a input type=&quot;file&quot; element
            upload = new UploadViaHiddenIframe({ id: count, uploadkey: PAGE.uploadkey });
            upload.addForm(uploaders, PAGE.dir, file);
        }

        if (upload) {
            uploadManager.addToQueue(upload);
            uploadManager.processQueue();
            clearFileInput();
        }
    }

    function handleFileDrop(event) {
        event.stopPropagation();
        event.preventDefault();

        if (!(supports_XHR2() &amp;&amp; supports_FileAPI())) {
            return;
        }

        var files = event.dataTransfer.files;

        if (files &amp;&amp; files.length &gt; 0) {
            if (files.length &gt; 1) {
                uploadfiles(files);
            } else {
                uploadfile(files[0]);
            }
        }

    }

    // this function loads when the YAHOO.util.Dom is ready
    function initialize() {
        YAHOO.util.Event.throwErrors = true;

        // set up drag n drop functionality
        // NOTE: We need XHR2 and File API support to adequately support drag n drop
        if (supports_XHR2() &amp;&amp; supports_FileAPI()) {
            var dropZone = document.getElementById(&quot;upload_drop_zone&quot;);
            dropZone.addEventListener(&quot;dragover&quot;, cancelEvent, false);
            dropZone.addEventListener(&quot;dragenter&quot;, cancelEvent, false);
            dropZone.addEventListener(&quot;drop&quot;, handleFileDrop, false);
        } else {
            var uploaderTextArea = document.getElementById(&quot;uploader_text_area&quot;);
            uploaderTextArea.style.display = &quot;none&quot;;
        }

        uploadManager = new UploadManager();
    }


    YAHOO.util.Event.onDOMReady(initialize);

    return {
        triggerFileSelection: function() {
            var file_input = document.getElementById(&quot;uploader_file_input&quot;);
            file_input.click();
        },

        goBackHandler: function(e) {
            if (fileManagerWindow &amp;&amp; fileManagerWindow.updateFileList) {

                // this is only needed in case the update call takes too long
                setTimeout(windowcloser, 5000);

                // update the list of files in the file manager window
                fileManagerWindow.updateFileList(PAGE.dir, 0, windowcloser);
                return false;
            } else {

                // this was not opened from the file manager, so close this window
                windowcloser();
                return true;
            }
        },

        uploadfile: uploadfile

    };

})(PAGE, $, LOCALE, YAHOO, sprintf, toHumanSize);
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2Ffrontend%2Fjupiter%2Fjs'>Back to Directory</a>