mcs/class/System/Test/System.Net/DnsCas.cs

   1 //
   2 // DnsCas.cs - CAS unit tests for System.Net.Dns class
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   8 //
   9
  10 #if !MOBILE
  11
  12 using NUnit.Framework;
  13
  14 using System;
  15 using System.Net;
  16 using System.Security;
  17 using System.Security.Permissions;
  18 using System.Threading;
  19
  20 namespace MonoCasTests.System.Net {
  21
  22         [TestFixture]
  23         [Category ("CAS")]
  24         [Category ("NotWorking")] // compiler (CSC) issue (on Windows)
  25         public class DnsCas {
  26
  27                 private const string site = "www.go-mono.com";
  28                 private const int timeout = 30000;
  29
  30                 static ManualResetEvent reset;
  31                 private string message;
  32                 private string hostname;
  33                 private IPAddress ip;
  34
  35                 [TestFixtureSetUp]
  36                 public void FixtureSetUp ()
  37                 {
  38                         reset = new ManualResetEvent (false);
  39                         hostname = Dns.GetHostName ();
  40                         ip = Dns.Resolve (site).AddressList[0];
  41                 }
  42
  43                 [TestFixtureTearDown]
  44                 public void FixtureTearDown ()
  45                 {
  46                         reset.Close ();
  47                 }
  48
  49                 [SetUp]
  50                 public void SetUp ()
  51                 {
  52                         if (!SecurityManager.SecurityEnabled)
  53                                 Assert.Ignore ("SecurityManager.SecurityEnabled is OFF");
  54                 }
  55
  56                 // test Demand by denying it's caller from the required permission
  57
  58                 [Test]
  59                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  60                 [ExpectedException (typeof (SecurityException))]
  61                 public void Deny_BeginGetHostName ()
  62                 {
  63                         Dns.BeginGetHostByName (null, null, null);
  64                 }
  65
  66                 [Test]
  67                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  68                 [ExpectedException (typeof (ArgumentNullException))]
  69                 public void Deny_EndGetHostByName ()
  70                 {
  71                         Dns.EndGetHostByName (null);
  72                 }
  73
  74                 [Test]
  75                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  76                 [ExpectedException (typeof (SecurityException))]
  77                 public void Deny_BeginResolve ()
  78                 {
  79                         Dns.BeginResolve (null, null, null);
  80                 }
  81
  82                 [Test]
  83                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  84                 [ExpectedException (typeof (ArgumentNullException))]
  85                 public void Deny_EndResolve ()
  86                 {
  87                         Dns.EndResolve (null);
  88                 }
  89
  90                 [Test]
  91                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  92                 [ExpectedException (typeof (SecurityException))]
  93                 public void Deny_GetHostByAddress_IPAddress ()
  94                 {
  95                         Dns.GetHostByAddress ((IPAddress)null);
  96                 }
  97
  98                 [Test]
  99                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 100                 [ExpectedException (typeof (SecurityException))]
 101                 public void Deny_GetHostByAddress_String ()
 102                 {
 103                         Dns.GetHostByAddress ((string)null);
 104                 }
 105
 106                 [Test]
 107                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 108                 [ExpectedException (typeof (SecurityException))]
 109                 public void Deny_GetHostByName ()
 110                 {
 111                         Dns.GetHostByName (site);
 112                 }
 113
 114                 [Test]
 115                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 116 #if NET_2_0
 117                 [ExpectedException (typeof (ArgumentNullException))]
 118                 // so it's not a declarative attribute on the method as the
 119                 // null check is done before throwing the SecurityException
 120 #else
 121                 [ExpectedException (typeof (SecurityException))]
 122 #endif
 123                 public void Deny_GetHostByName_Null ()
 124                 {
 125                         Dns.GetHostByName (null);
 126                 }
 127
 128                 [Test]
 129                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 130                 [ExpectedException (typeof (SecurityException))]
 131                 public void Deny_GetHostByName_HostName ()
 132                 {
 133                         // ... so my first guess is that you can only query
 134                         // yourself without having unrestricted DnsPermission
 135                         Assert.IsNotNull (Dns.GetHostByName (hostname));
 136                         // but that's wrong :-(
 137                 }
 138
 139                 [Test]
 140                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 141                 [ExpectedException (typeof (SecurityException))]
 142                 public void Deny_GetHostName ()
 143                 {
 144                         Dns.GetHostName ();
 145                 }
 146
 147                 [Test]
 148                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 149                 [ExpectedException (typeof (SecurityException))]
 150                 public void Deny_Resolve ()
 151                 {
 152                         Dns.Resolve (null);
 153                 }
 154
 155 #if NET_2_0
 156                 // TODO: New 2.0 methods aren't yet implemented in Mono
 157 /*
 158                 [Test]
 159                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 160                 [ExpectedException (typeof (SecurityException))]
 161                 public void Deny_BeginGetHostAddresses ()
 162                 {
 163                         Dns.BeginGetHostAddresses (null, null, null);
 164                 }
 165
 166                 [Test]
 167                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 168                 [ExpectedException (typeof (ArgumentNullException))]
 169                 public void Deny_EndGetHostAddresses ()
 170                 {
 171                         Dns.EndGetHostAddresses (null);
 172                 }
 173
 174                 [Test]
 175                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 176                 [ExpectedException (typeof (SecurityException))]
 177                 public void Deny_BeginGetHostEntry_IPAddress ()
 178                 {
 179                         Dns.BeginGetHostEntry ((IPAddress)null, null, null);
 180                 }
 181
 182                 [Test]
 183                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 184                 [ExpectedException (typeof (SecurityException))]
 185                 public void Deny_BeginGetHostEntry_String ()
 186                 {
 187                         Dns.BeginGetHostEntry ((string)null, null, null);
 188                 }
 189
 190                 [Test]
 191                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 192                 [ExpectedException (typeof (ArgumentNullException))]
 193                 public void Deny_EndGetHostEntry ()
 194                 {
 195                         Dns.EndGetHostEntry (null);
 196                 }
 197
 198                 [Test]
 199                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 200                 [ExpectedException (typeof (SecurityException))]
 201                 public void Deny_GetHostEntry_IPAddress ()
 202                 {
 203                         Dns.GetHostEntry ((IPAddress)null);
 204                 }
 205
 206                 [Test]
 207                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 208                 [ExpectedException (typeof (SecurityException))]
 209                 public void Deny_GetHostEntry_String ()
 210                 {
 211                         Dns.GetHostEntry ((string)null);
 212                 }
 213
 214                 [Test]
 215                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 216                 [ExpectedException (typeof (SecurityException))]
 217                 public void Deny_GetHostAddresses ()
 218                 {
 219                         Dns.GetHostAddresses (null);
 220                 }
 221 */
 222 #endif
 223
 224                 // ensure that only DnsPermission is required to call the methods
 225
 226                 [Test]
 227                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 228                 [ExpectedException (typeof (ArgumentNullException))]
 229                 public void PermitOnly_BeginGetHostName ()
 230                 {
 231                         Dns.BeginGetHostByName (null, null, null);
 232                 }
 233
 234                 [Test]
 235                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 236                 [ExpectedException (typeof (ArgumentNullException))]
 237                 public void PermitOnly_BeginResolve ()
 238                 {
 239                         Dns.BeginResolve (null, null, null);
 240                 }
 241
 242                 [Test]
 243                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 244                 [ExpectedException (typeof (ArgumentNullException))]
 245                 public void PermitOnly_GetHostByAddress_IPAddress ()
 246                 {
 247                         Dns.GetHostByAddress ((IPAddress)null);
 248                 }
 249
 250                 [Test]
 251                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 252                 [ExpectedException (typeof (ArgumentNullException))]
 253                 public void PermitOnly_GetHostByAddress_String ()
 254                 {
 255                         Dns.GetHostByAddress ((string)null);
 256                 }
 257
 258                 [Test]
 259                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 260                 [ExpectedException (typeof (ArgumentNullException))]
 261                 public void PermitOnly_GetHostByName ()
 262                 {
 263                         Dns.GetHostByName (null);
 264                 }
 265
 266                 [Test]
 267                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 268                 public void PermitOnly_GetHostName ()
 269                 {
 270                         Assert.IsNotNull (Dns.GetHostName ());
 271                 }
 272
 273                 [Test]
 274                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 275                 [ExpectedException (typeof (ArgumentNullException))]
 276                 public void PermitOnly_Resolve ()
 277                 {
 278                         Dns.Resolve (null);
 279                 }
 280
 281 #if NET_2_0
 282                 // TODO: New 2.0 methods aren't yet implemented in Mono
 283 /*
 284                 [Test]
 285                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 286                 [ExpectedException (typeof (ArgumentNullException))]
 287                 public void PermitOnly_BeginGetHostAddresses ()
 288                 {
 289                         Dns.BeginGetHostAddresses (null, null, null);
 290                 }
 291
 292                 [Test]
 293                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 294                 [ExpectedException (typeof (ArgumentNullException))]
 295                 public void PermitOnly_EndGetHostAddresses ()
 296                 {
 297                         Dns.EndGetHostAddresses (null);
 298                 }
 299
 300                 [Test]
 301                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 302                 [ExpectedException (typeof (ArgumentNullException))]
 303                 public void PermitOnly_BeginGetHostEntry_IPAddress ()
 304                 {
 305                         Dns.BeginGetHostEntry ((IPAddress)null, null, null);
 306                 }
 307
 308                 [Test]
 309                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 310                 [ExpectedException (typeof (ArgumentNullException))]
 311                 public void PermitOnly_BeginGetHostEntry_String ()
 312                 {
 313                         Dns.BeginGetHostEntry ((string)null, null, null);
 314                 }
 315
 316                 [Test]
 317                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 318                 [ExpectedException (typeof (ArgumentNullException))]
 319                 public void PermitOnly_EndGetHostEntry ()
 320                 {
 321                         Dns.EndGetHostEntry (null);
 322                 }
 323
 324                 [Test]
 325                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 326                 [ExpectedException (typeof (ArgumentNullException))]
 327                 public void PermitOnly_GetHostEntry_IPAddress ()
 328                 {
 329                         Dns.GetHostEntry ((IPAddress)null);
 330                 }
 331
 332                 [Test]
 333                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 334                 [ExpectedException (typeof (ArgumentNullException))]
 335                 public void PermitOnly_GetHostEntry_String ()
 336                 {
 337                         Dns.GetHostEntry ((string)null);
 338                 }
 339
 340                 [Test]
 341                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 342                 [ExpectedException (typeof (ArgumentNullException))]
 343                 public void PermitOnly_GetHostAddresses ()
 344                 {
 345                         Dns.GetHostAddresses (null);
 346                 }
 347 */
 348 #endif
 349
 350                 // async tests (for stack propagation)
 351
 352                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 353                 private void GetHostByNameCallback (IAsyncResult ar)
 354                 {
 355                         Dns.EndGetHostByName (ar);
 356                         try {
 357                                 // can we do something bad here ?
 358                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 359                                 message = "Expected a SecurityException";
 360                         }
 361                         catch (SecurityException) {
 362                                 message = null;
 363                                 reset.Set ();
 364                         }
 365                         catch (Exception e)
 366                         {
 367                                 message = e.ToString ();
 368                         }
 369                 }
 370
 371                 [Test]
 372                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 373                 public void AsyncGetHostByName ()
 374                 {
 375                         message = "AsyncGetHostByName";
 376                         reset.Reset ();
 377                         IAsyncResult r = Dns.BeginGetHostByName (site, new AsyncCallback (GetHostByNameCallback), null);
 378                         Assert.IsNotNull (r, "IAsyncResult");
 379                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 380                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 381                         if (!reset.WaitOne (timeout, true))
 382                                 Assert.Ignore ("Timeout");
 383                         Assert.IsNull (message, message);
 384                 }
 385
 386                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 387                 private void ResolveCallback (IAsyncResult ar)
 388                 {
 389                         Dns.EndResolve (ar);
 390                         try {
 391                                 // can we do something bad here ?
 392                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 393                                 message = "Expected a SecurityException";
 394                         }
 395                         catch (SecurityException) {
 396                                 message = null;
 397                                 reset.Set ();
 398                         }
 399                         catch (Exception e) {
 400                                 message = e.ToString ();
 401                         }
 402                 }
 403
 404                 [Test]
 405                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 406                 public void AsyncResolve ()
 407                 {
 408                         message = "AsyncResolve";
 409                         reset.Reset ();
 410                         IAsyncResult r = Dns.BeginResolve (site, new AsyncCallback (ResolveCallback), null);
 411                         Assert.IsNotNull (r, "IAsyncResult");
 412                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 413                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 414                         if (!reset.WaitOne (timeout, true))
 415                                 Assert.Ignore ("Timeout");
 416                         Assert.IsNull (message, message);
 417                 }
 418
 419 #if NET_2_0
 420                 // TODO: New 2.0 methods aren't yet implemented in Mono
 421 /*
 422                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 423                 private void GetHostEntryCallback (IAsyncResult ar)
 424                 {
 425                         Dns.EndGetHostEntry (ar);
 426                         try {
 427                                 // can we do something bad here ?
 428                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 429                                 message = "Expected a SecurityException";
 430                         }
 431                         catch (SecurityException) {
 432                                 message = null;
 433                                 reset.Set ();
 434                         }
 435                         catch (Exception e) {
 436                                 message = e.ToString ();
 437                         }
 438                 }
 439
 440                 [Test]
 441                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 442                 [Ignore ("fails when EndGetHostEntry is called")]
 443                 public void AsyncGetHostEntry_IPAddress ()
 444                 {
 445                         message = "AsyncGetHostEntry_IPAddress";
 446                         reset.Reset ();
 447                         IAsyncResult r = Dns.BeginGetHostEntry (ip, new AsyncCallback (GetHostEntryCallback), null);
 448                         Assert.IsNotNull (r, "IAsyncResult");
 449                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 450                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 451                         if (!reset.WaitOne (timeout, true))
 452                                 Assert.Ignore ("Timeout");
 453                         Assert.IsNull (message, message);
 454                 }
 455
 456                 [Test]
 457                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 458                 public void AsyncGetHostEntry_String ()
 459                 {
 460                         message = "AsyncGetHostEntry_String";
 461                         reset.Reset ();
 462                         IAsyncResult r = Dns.BeginGetHostEntry (site, new AsyncCallback (GetHostEntryCallback), null);
 463                         Assert.IsNotNull (r, "IAsyncResult");
 464                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 465                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 466                         if (!reset.WaitOne (timeout, true))
 467                                 Assert.Ignore ("Timeout");
 468                         Assert.IsNull (message, message);
 469                 }
 470
 471                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 472                 private void GetHostAddressesCallback (IAsyncResult ar)
 473                 {
 474                         Dns.EndGetHostEntry (ar);
 475                         try {
 476                                 // can we do something bad here ?
 477                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 478                                 message = "Expected a SecurityException";
 479                         }
 480                         catch (SecurityException) {
 481                                 message = null;
 482                                 reset.Set ();
 483                         }
 484                         catch (Exception e) {
 485                                 message = e.ToString ();
 486                         }
 487                 }
 488
 489                 [Test]
 490                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 491                 public void AsyncGetHostAddresses ()
 492                 {
 493                         message = "AsyncGetHostAddresses";
 494                         reset.Reset ();
 495                         IAsyncResult r = Dns.BeginGetHostAddresses (site, new AsyncCallback (GetHostAddressesCallback), null);
 496                         Assert.IsNotNull (r, "IAsyncResult");
 497                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 498                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 499                         if (!reset.WaitOne (timeout, true))
 500                                 Assert.Ignore ("Timeout");
 501                         Assert.IsNull (message, message);
 502                 }
 503 */
 504 #endif
 505         }
 506 }
 507
 508 #endif