root/trunk/digitalme/launchers/csharp/Novell.IdentityModel.Selectors/DigitalMeSelector.cs

using System;
using System.Text;

using System.IO;
using System.Diagnostics;


namespace Novell.IdentityModel.Selectors
{
    public class DigitalMeSelector
    {
        private static string DM_TEST_ARG_STR = "--test";
        private static string DM_GET_TOKEN_ARG_STR = "--gettoken ";
        private static string DM_TRUSTED_ISSUER_URIS_ARG_STR = "--issuers";
        private static string DM_RECIPIENT_ARG_STR = "--recipient";
        private static string DM_REQUIRED_CLAIMS_ARG_STR = "--reqclaims";
        private static string DM_OPTIONAL_CLAIMS_ARG_STR = "--optclaims";
        private static string DM_TOKEN_TYPE_ARG_STR = "--tokentype";
        private static string DM_PRIVACY_POLICY_FILE_ARG_STR = "--privfile";
        private static string DM_CERT_FILE_ARG_STR = "--certfile";
        private static string DM_TOKEN_OUTPUT_FILE_ARG_STR = "--tokenfile";
        private static string DM_NON_SECURE_DESKTOP_ARG_STR = "--nonsecure ";
        private static string DM_VERSION_ARG_STR = "--version";
        private static string DM_ISSUER_POLICY_ARG_STR = "--issuerpolicy";

        // this is Microsofts API for GetToken
        // Does mono support classes such as SecurityTokenSerializer?
        /*
        public static void GetToken(XmlElement endpoint,
                                     IEnumerable<XmlElement> policy,
                                     XmlElment requiredRemoteTokenElement,
                                     SecurityTokenSerializer tokenSerializer)
        {
        }
        */

        public static void Manage()
        {
            String sExePath = GetExePath();
            if (null != sExePath)
            {
                LaunchSelector(sExePath, null);
            }
        }

        public static void Import(String sFilePath)
        {
            String sExePath = GetExePath();
            StringBuilder sbArgs = new StringBuilder();

            sbArgs.Append("--import ");
            sbArgs.Append(sFilePath);

            if (null != sExePath)
            {
                LaunchSelector(sExePath, sbArgs);
            }
        }

        public static byte[] GetToken(String sRelyingParty,
                                    String[] saRequiredClaims,
                                    String[] saOptionalClaims,
                                    String sTokenType)
        {
            String sExePath = GetExePath();
            if (null != sExePath)
            {

                StringBuilder sbArgs = new StringBuilder();
                String sTempFileName = System.IO.Path.GetTempFileName();

                // build argument string
                sbArgs.Append(DM_GET_TOKEN_ARG_STR);
                sbArgs.AppendFormat("{0}=\"{1}\" ", DM_TOKEN_OUTPUT_FILE_ARG_STR, sTempFileName);
                sbArgs.AppendFormat("{0}=\"{1}\" ", DM_RECIPIENT_ARG_STR, sRelyingParty);

                // required claims
                if (saRequiredClaims != null)
                {
                    sbArgs.AppendFormat(" {0}=\"", DM_REQUIRED_CLAIMS_ARG_STR);
                    foreach (string sClaim in saRequiredClaims)
                    {
                        sbArgs.Append(sClaim);
                        sbArgs.Append(" ");
                    }
                    sbArgs.Append("\"");
                }

                // optional claims
                if (saOptionalClaims != null)
                {
                    sbArgs.AppendFormat(" {0}=\"", DM_OPTIONAL_CLAIMS_ARG_STR);
                    foreach (string sClaim in saOptionalClaims)
                    {
                        sbArgs.Append(sClaim);
                        sbArgs.Append(" ");
                    }
                    sbArgs.Append("\"");
                }

                // tokentype
                if (sTokenType != null)
                {
                    sbArgs.AppendFormat(" {0}=\"{1}\"", DM_TOKEN_TYPE_ARG_STR, sTokenType);
                }

                LaunchSelector(sExePath, sbArgs);

                // read token file
                FileStream fs = new FileStream(sTempFileName, FileMode.Open);
                byte[] baToken = new byte[fs.Length];
                fs.Read(baToken, 0, (int)fs.Length);

                File.Delete(sTempFileName);

                DbgLog("Token: " + System.Text.Encoding.ASCII.GetString(baToken));
                return baToken;
            }
            else
            {
                DbgLog("DigitalMe application not found");
            }
            return null;
        }

        private static void LaunchSelector(String sExePath, StringBuilder sbArgs)
        {
            try
            {
                // launch selector
                Process myProcess = null;
                StreamReader myStreamReader = null;

                myProcess = new Process();
                ProcessStartInfo myProcessStartInfo = new ProcessStartInfo(sExePath);

                if (sbArgs != null)
                {
                    myProcessStartInfo.Arguments = sbArgs.ToString();
                    DbgLog("Args:" + myProcessStartInfo.Arguments);
                }

                myProcessStartInfo.UseShellExecute = false;
                myProcessStartInfo.RedirectStandardOutput = true;

                myProcess.StartInfo = myProcessStartInfo;
                myProcess.Start();
                myProcess.WaitForExit();

                myStreamReader = myProcess.StandardOutput;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }
        }


        private static String GetExePath()
        {

            int platform = (int)Environment.OSVersion.Platform;
            String sUserhome = Environment.GetEnvironmentVariable("HOME");

            String[] paths = {"/usr/local/lib/digitalme/bin/digitalme",
                                "/usr/lib/digitalme/bin/digitalme",
                                sUserhome + "/Desktop/DigitalMe.app/Contents/MacOS/DigitalMe",
                                "/Applications/DigitalMe.app/Contents/MacOS/DigitalMe",
                                "/Applications/Utilities/DigitalMe.app/Contents/MacOS"};


            DbgLog("Platform: " + platform.ToString());
            DbgLog("OSVersion: " + Environment.OSVersion.Version.ToString());

            foreach (string path in paths)
            {
                if (File.Exists(path))
                {
                    DbgLog(path);
                    return path;
                }
            }


            if ((128 == platform) || (4 == platform))
            {
                return "/usr/local/lib/digitalme/bin/digitalme";
            }
            else
            {
                DbgLog("Platform: " + platform.ToString());
            }

            return null;
        }

        private static void DbgLog(String sMessage)
        {
#if DEBUG
            Console.WriteLine(sMessage);
#endif
        }
    }
}