YouTube.cpp

Go to the documentation of this file.

#include "YouTube.h"

#include "D:/Rise Base/RakNet/Source/TCPInterface.h"
#include "D:/Rise Base/RakNet/Source/GetTime.h"
#include "D:/Rise Base/RakNet/Source/RakSleep.h"
#include "D:/Rise Base/RakNet/Source/Base64Encoder.h"
#include "D:/Rise Base/RakNet/Source/HTTPConnection.h"

#include <io.h>
#include <fcntl.h>
#include <share.h>
#include <sys/stat.h>

namespace Devices
{
        void YouTube::Initialize(Logger* prmLogger, Bus* prmBus, YouTubeConfig* prmConfig)
        {
                logger = prmLogger;
                bus = prmBus;
                config = prmConfig;
        }

        void YouTube::FrameMove() const
        {
                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command command = bus->commandStream.at(i);
                        if (command.delay != 0.0f) continue;

                        if (command.name == "YouTubePublish")
                        {
                        }
                }
        }

        std::string YouTube::Publish(PublishParameters params) const
        {
                std::string url = "";

                std::string authToken = Login();
                if (authToken.empty())
                {
                        logger->Log("YouTube::Publish No AuthToken available, bailing out!", Logger::Error);
                        return url;
                }

                RakNet::TCPInterface tcp;
                RakNet::HTTPConnection http;
                http.Init(&tcp, "uploads.gdata.youtube.com", 80);

                std::string apiUrl = "/feeds/api/users/default/uploads";
                std::string boundary = "f93dcbA3";

                std::string header = "";
                header += "Authorization: GoogleLogin auth=" + authToken + "\n";
                header += "Content-Type: multipart/related; boundary=\"" + boundary + "\"\n";
                header += "GData-Version: 2.1\n";
                header += "X-GData-Key: key=" + config->developerKey + "\n";
                header += "Slug: test.mp4\n";
                header += "Connection: close\n";

                std::string body = "";
                body += "--" + boundary + "\n";
                body += "Content-Type: application/atom+xml; charset=UTF-8\n";
                body += "\n";
                body += "<?xml version=\"1.0\"?>\n";
                body += "<entry xmlns=\"http://www.w3.org/2005/Atom\"\n";
                body += "  xmlns:media=\"http://search.yahoo.com/mrss/\"\n";
                body += "  xmlns:yt=\"http://gdata.youtube.com/schemas/2007\">\n";
                body += "  <media:group>\n";
                body += "    <media:title type=\"plain\">" + params.title + "</media:title>\n";
                body += "    <media:description type=\"plain\">\n";
                body += "      " + params.description + "\n";
                body += "    </media:description>\n";
                body += "    <media:category\n";
                body += "      scheme=\"http://gdata.youtube.com/schemas/2007/categories.cat\">" + params.category + "\n";
                body += "    </media:category>\n";
                body += "    <media:keywords>" + params.keywords + "</media:keywords>\n";
                body += "  </media:group>\n";
                if (params.privacy == PrivacyEnum::Unlisted)
                {
                        body += "  <yt:accessControl action='list' permission='denied' />\n"; // unlisted... can also be the channel default!
                }
                body += "</entry>\n";
                body += "--" + boundary + "\n";
                body += "Content-Type: video/mp4\n"; // can also be video/mpeg or application/octet-stream
                body += "Content-Transfer-Encoding: base64\n";
                body += "\n";

                int handle = -1;
                _sopen_s(&handle, params.pathfilename.c_str(), _O_RDONLY | _O_BINARY, SH_DENYNO, S_IWRITE);
                if (handle == -1)
                {
                        std::string msg = "YouTube::Publish Could not open file: " + params.pathfilename;
                        logger->Log(msg.c_str(), Logger::Error, errno);
                        return url;
                }

                int bytes = _filelength(handle);
                void* data = malloc(bytes);
                _read(handle, data, bytes);
                _close(handle);

                char* outputData = new char[bytes * 3];
                Base64Encoding(static_cast<unsigned char *>(data), bytes, outputData);
                body += outputData;
                SAFE_DELETE(outputData);
                SAFE_DELETE(data);

                body += "--" + boundary + "--";

                http.Post(apiUrl.c_str(), body.c_str(), header.c_str());

                if (!tcp.Start(0, 0))
                {
                        logger->Log("YouTube::Publish Unknown error starting TCP", Logger::Error);
                        return url;
                }

                logger->Log("YouTube::Publish Processing HTTP POST...");
                RakNet::TimeMS timeoutTime = RakNet::GetTimeMS() + 60000;
                while (RakNet::GetTimeMS() < timeoutTime)
                {
                        RakNet::Packet* packet = tcp.Receive();
                        if (packet)
                        {
                                http.ProcessTCPPacket(packet);
                                tcp.DeallocatePacket(packet);
                        }

                        http.Update();
                        if (!http.IsBusy())
                        {
                                int code = 0;
                                RakNet::RakString fileContents;
                                if (http.HasBadResponse(&code, &fileContents))
                                {
                                        logger->Log(fileContents.C_String(), Logger::Error, code);
                                }
                                else
                                {
                                        fileContents = http.Read();
                                        url = fileContents.C_String();
                                        UINT ordinal = url.find("href='");
                                        if (ordinal != url.npos)
                                        {
                                                UINT endOrdinal = url.find("&amp;feature=youtube_gdata'");
                                                if (endOrdinal != url.npos)
                                                {
                                                        ordinal += 6; // get rid of leading junk
                                                        url = url.substr(ordinal, endOrdinal - ordinal);
                                                        std::string msg = "YouTube::Publish Success!  Returning: " + url;
                                                        logger->Log(msg.c_str());
                                                }
                                                else
                                                {
                                                        logger->Log("YouTube::Publish Unexpected return data to follow...", Logger::Warn);
                                                        logger->Log(url.c_str(), Logger::Error);
                                                        url = "";
                                                }
                                        }
                                        else
                                        {
                                                logger->Log("YouTube::Publish Unexpected return data to follow...", Logger::Warn);
                                                logger->Log(url.c_str(), Logger::Error);
                                                url = "";
                                        }
                                }

                                break;
                        }

                        // Prevent 100% cpu usage
                        RakSleep(30);
                }

                if (RakNet::GetTimeMS() >= timeoutTime)
                {
                        logger->Log("YouTube::Publish Timeout!", Logger::Error);
                }

                tcp.Stop();

                return url;
        }

        std::string YouTube::Login() const
        {
                std::string authToken = "";

                RakNet::TCPInterface tcp;
                RakNet::HTTPConnection http;
                http.Init(&tcp, "www.google.com", 443);

                std::string url = "/accounts/ClientLogin?Email=" + config->username + "&Passwd=" + config->password + "&service=youtube&source=" + config->source;
                http.Get(url.c_str());

                if (!tcp.Start(0, 0))
                {
                        logger->Log("YouTube::Login Unknown error starting TCP", Logger::Error);
                        return authToken;
                }

                logger->Log("YouTube::Login Starting SSL Client...");
                tcp.StartSSLClient(http.GetServerAddress());

                logger->Log("YouTube::Login Processing HTTP GET...");
                RakNet::TimeMS timeoutTime = RakNet::GetTimeMS() + 5000;
                while (RakNet::GetTimeMS() < timeoutTime)
                {
                        RakNet::Packet* packet = tcp.Receive();
                        if (packet)
                        {
                                http.ProcessTCPPacket(packet);
                                tcp.DeallocatePacket(packet);
                        }

                        http.Update(true);
                        if (!http.IsBusy())
                        {
                                RakNet::RakString fileContents = http.Read();
                                authToken = fileContents.C_String();
                                break;
                        }

                        // Prevent 100% cpu usage
                        RakSleep(30);
                }

                if (RakNet::GetTimeMS() >= timeoutTime)
                {
                        logger->Log("YouTube::Login Timeout!", Logger::Error);
                }
                else if (authToken.empty())
                {
                        logger->Log("YouTube::Login Response was empty!", Logger::Error);
                }
                else
                {
                        UINT ordinal = authToken.find("Auth=");
                        //UINT ordinal = authToken.find("SID=");
                        if (ordinal != std::string::npos)
                        {
                                authToken = authToken.substr(ordinal + 5);
                                //authToken = authToken.substr(ordinal);
                                authToken = authToken.substr(0, authToken.length() - 1); // trim trailing return
                                char msg[999];
                                sprintf_s(msg, 999, "YouTube::Login Returning AuthToken: %s (...)", authToken.substr(0, 32).c_str());
                                logger->Log(msg);
                        }
                        else
                        {
                                logger->Log("YouTube::Login Could not find Auth= in reponse!  Response text to follow...", Logger::Warn);
                                logger->Log(authToken.c_str(), Logger::Error);
                                authToken = "";
                        }
                }

                tcp.Stop();

                return authToken;
        }
}