Source file
src/net/url/url.go
Documentation: net/url
1
2
3
4
5
6 package url
7
8
9
10
11
12
13 import (
14 "errors"
15 "fmt"
16 "path"
17 "sort"
18 "strconv"
19 "strings"
20 )
21
22
23 type Error struct {
24 Op string
25 URL string
26 Err error
27 }
28
29 func (e *Error) Unwrap() error { return e.Err }
30 func (e *Error) Error() string { return fmt.Sprintf("%s %q: %s", e.Op, e.URL, e.Err) }
31
32 func (e *Error) Timeout() bool {
33 t, ok := e.Err.(interface {
34 Timeout() bool
35 })
36 return ok && t.Timeout()
37 }
38
39 func (e *Error) Temporary() bool {
40 t, ok := e.Err.(interface {
41 Temporary() bool
42 })
43 return ok && t.Temporary()
44 }
45
46 const upperhex = "0123456789ABCDEF"
47
48 func ishex(c byte) bool {
49 switch {
50 case '0' <= c && c <= '9':
51 return true
52 case 'a' <= c && c <= 'f':
53 return true
54 case 'A' <= c && c <= 'F':
55 return true
56 }
57 return false
58 }
59
60 func unhex(c byte) byte {
61 switch {
62 case '0' <= c && c <= '9':
63 return c - '0'
64 case 'a' <= c && c <= 'f':
65 return c - 'a' + 10
66 case 'A' <= c && c <= 'F':
67 return c - 'A' + 10
68 }
69 return 0
70 }
71
72 type encoding int
73
74 const (
75 encodePath encoding = 1 + iota
76 encodePathSegment
77 encodeHost
78 encodeZone
79 encodeUserPassword
80 encodeQueryComponent
81 encodeFragment
82 )
83
84 type EscapeError string
85
86 func (e EscapeError) Error() string {
87 return "invalid URL escape " + strconv.Quote(string(e))
88 }
89
90 type InvalidHostError string
91
92 func (e InvalidHostError) Error() string {
93 return "invalid character " + strconv.Quote(string(e)) + " in host name"
94 }
95
96
97
98
99
100
101 func shouldEscape(c byte, mode encoding) bool {
102
103 if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {
104 return false
105 }
106
107 if mode == encodeHost || mode == encodeZone {
108
109
110
111
112
113
114
115
116
117 switch c {
118 case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '[', ']', '<', '>', '"':
119 return false
120 }
121 }
122
123 switch c {
124 case '-', '_', '.', '~':
125 return false
126
127 case '$', '&', '+', ',', '/', ':', ';', '=', '?', '@':
128
129
130 switch mode {
131 case encodePath:
132
133
134
135
136 return c == '?'
137
138 case encodePathSegment:
139
140
141 return c == '/' || c == ';' || c == ',' || c == '?'
142
143 case encodeUserPassword:
144
145
146
147
148 return c == '@' || c == '/' || c == '?' || c == ':'
149
150 case encodeQueryComponent:
151
152 return true
153
154 case encodeFragment:
155
156
157 return false
158 }
159 }
160
161 if mode == encodeFragment {
162
163
164
165
166
167
168 switch c {
169 case '!', '(', ')', '*':
170 return false
171 }
172 }
173
174
175 return true
176 }
177
178
179
180
181
182
183 func QueryUnescape(s string) (string, error) {
184 return unescape(s, encodeQueryComponent)
185 }
186
187
188
189
190
191
192
193
194 func PathUnescape(s string) (string, error) {
195 return unescape(s, encodePathSegment)
196 }
197
198
199
200 func unescape(s string, mode encoding) (string, error) {
201
202 n := 0
203 hasPlus := false
204 for i := 0; i < len(s); {
205 switch s[i] {
206 case '%':
207 n++
208 if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) {
209 s = s[i:]
210 if len(s) > 3 {
211 s = s[:3]
212 }
213 return "", EscapeError(s)
214 }
215
216
217
218
219
220
221 if mode == encodeHost && unhex(s[i+1]) < 8 && s[i:i+3] != "%25" {
222 return "", EscapeError(s[i : i+3])
223 }
224 if mode == encodeZone {
225
226
227
228
229
230
231
232 v := unhex(s[i+1])<<4 | unhex(s[i+2])
233 if s[i:i+3] != "%25" && v != ' ' && shouldEscape(v, encodeHost) {
234 return "", EscapeError(s[i : i+3])
235 }
236 }
237 i += 3
238 case '+':
239 hasPlus = mode == encodeQueryComponent
240 i++
241 default:
242 if (mode == encodeHost || mode == encodeZone) && s[i] < 0x80 && shouldEscape(s[i], mode) {
243 return "", InvalidHostError(s[i : i+1])
244 }
245 i++
246 }
247 }
248
249 if n == 0 && !hasPlus {
250 return s, nil
251 }
252
253 var t strings.Builder
254 t.Grow(len(s) - 2*n)
255 for i := 0; i < len(s); i++ {
256 switch s[i] {
257 case '%':
258 t.WriteByte(unhex(s[i+1])<<4 | unhex(s[i+2]))
259 i += 2
260 case '+':
261 if mode == encodeQueryComponent {
262 t.WriteByte(' ')
263 } else {
264 t.WriteByte('+')
265 }
266 default:
267 t.WriteByte(s[i])
268 }
269 }
270 return t.String(), nil
271 }
272
273
274
275 func QueryEscape(s string) string {
276 return escape(s, encodeQueryComponent)
277 }
278
279
280
281 func PathEscape(s string) string {
282 return escape(s, encodePathSegment)
283 }
284
285 func escape(s string, mode encoding) string {
286 spaceCount, hexCount := 0, 0
287 for i := 0; i < len(s); i++ {
288 c := s[i]
289 if shouldEscape(c, mode) {
290 if c == ' ' && mode == encodeQueryComponent {
291 spaceCount++
292 } else {
293 hexCount++
294 }
295 }
296 }
297
298 if spaceCount == 0 && hexCount == 0 {
299 return s
300 }
301
302 var buf [64]byte
303 var t []byte
304
305 required := len(s) + 2*hexCount
306 if required <= len(buf) {
307 t = buf[:required]
308 } else {
309 t = make([]byte, required)
310 }
311
312 if hexCount == 0 {
313 copy(t, s)
314 for i := 0; i < len(s); i++ {
315 if s[i] == ' ' {
316 t[i] = '+'
317 }
318 }
319 return string(t)
320 }
321
322 j := 0
323 for i := 0; i < len(s); i++ {
324 switch c := s[i]; {
325 case c == ' ' && mode == encodeQueryComponent:
326 t[j] = '+'
327 j++
328 case shouldEscape(c, mode):
329 t[j] = '%'
330 t[j+1] = upperhex[c>>4]
331 t[j+2] = upperhex[c&15]
332 j += 3
333 default:
334 t[j] = s[i]
335 j++
336 }
337 }
338 return string(t)
339 }
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359 type URL struct {
360 Scheme string
361 Opaque string
362 User *Userinfo
363 Host string
364 Path string
365 RawPath string
366 OmitHost bool
367 ForceQuery bool
368 RawQuery string
369 Fragment string
370 RawFragment string
371 }
372
373
374
375 func User(username string) *Userinfo {
376 return &Userinfo{username, "", false}
377 }
378
379
380
381
382
383
384
385
386
387 func UserPassword(username, password string) *Userinfo {
388 return &Userinfo{username, password, true}
389 }
390
391
392
393
394
395 type Userinfo struct {
396 username string
397 password string
398 passwordSet bool
399 }
400
401
402 func (u *Userinfo) Username() string {
403 if u == nil {
404 return ""
405 }
406 return u.username
407 }
408
409
410 func (u *Userinfo) Password() (string, bool) {
411 if u == nil {
412 return "", false
413 }
414 return u.password, u.passwordSet
415 }
416
417
418
419 func (u *Userinfo) String() string {
420 if u == nil {
421 return ""
422 }
423 s := escape(u.username, encodeUserPassword)
424 if u.passwordSet {
425 s += ":" + escape(u.password, encodeUserPassword)
426 }
427 return s
428 }
429
430
431
432
433 func getScheme(rawURL string) (scheme, path string, err error) {
434 for i := 0; i < len(rawURL); i++ {
435 c := rawURL[i]
436 switch {
437 case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
438
439 case '0' <= c && c <= '9' || c == '+' || c == '-' || c == '.':
440 if i == 0 {
441 return "", rawURL, nil
442 }
443 case c == ':':
444 if i == 0 {
445 return "", "", errors.New("missing protocol scheme")
446 }
447 return rawURL[:i], rawURL[i+1:], nil
448 default:
449
450
451 return "", rawURL, nil
452 }
453 }
454 return "", rawURL, nil
455 }
456
457
458
459
460
461
462
463 func Parse(rawURL string) (*URL, error) {
464
465 u, frag, _ := strings.Cut(rawURL, "#")
466 url, err := parse(u, false)
467 if err != nil {
468 return nil, &Error{"parse", u, err}
469 }
470 if frag == "" {
471 return url, nil
472 }
473 if err = url.setFragment(frag); err != nil {
474 return nil, &Error{"parse", rawURL, err}
475 }
476 return url, nil
477 }
478
479
480
481
482
483
484 func ParseRequestURI(rawURL string) (*URL, error) {
485 url, err := parse(rawURL, true)
486 if err != nil {
487 return nil, &Error{"parse", rawURL, err}
488 }
489 return url, nil
490 }
491
492
493
494
495
496 func parse(rawURL string, viaRequest bool) (*URL, error) {
497 var rest string
498 var err error
499
500 if stringContainsCTLByte(rawURL) {
501 return nil, errors.New("net/url: invalid control character in URL")
502 }
503
504 if rawURL == "" && viaRequest {
505 return nil, errors.New("empty url")
506 }
507 url := new(URL)
508
509 if rawURL == "*" {
510 url.Path = "*"
511 return url, nil
512 }
513
514
515
516 if url.Scheme, rest, err = getScheme(rawURL); err != nil {
517 return nil, err
518 }
519 url.Scheme = strings.ToLower(url.Scheme)
520
521 if strings.HasSuffix(rest, "?") && strings.Count(rest, "?") == 1 {
522 url.ForceQuery = true
523 rest = rest[:len(rest)-1]
524 } else {
525 rest, url.RawQuery, _ = strings.Cut(rest, "?")
526 }
527
528 if !strings.HasPrefix(rest, "/") {
529 if url.Scheme != "" {
530
531 url.Opaque = rest
532 return url, nil
533 }
534 if viaRequest {
535 return nil, errors.New("invalid URI for request")
536 }
537
538
539
540
541
542
543
544 if segment, _, _ := strings.Cut(rest, "/"); strings.Contains(segment, ":") {
545
546 return nil, errors.New("first path segment in URL cannot contain colon")
547 }
548 }
549
550 if (url.Scheme != "" || !viaRequest && !strings.HasPrefix(rest, "///")) && strings.HasPrefix(rest, "//") {
551 var authority string
552 authority, rest = rest[2:], ""
553 if i := strings.Index(authority, "/"); i >= 0 {
554 authority, rest = authority[:i], authority[i:]
555 }
556 url.User, url.Host, err = parseAuthority(authority)
557 if err != nil {
558 return nil, err
559 }
560 } else if url.Scheme != "" && strings.HasPrefix(rest, "/") {
561
562
563 url.OmitHost = true
564 }
565
566
567
568
569
570 if err := url.setPath(rest); err != nil {
571 return nil, err
572 }
573 return url, nil
574 }
575
576 func parseAuthority(authority string) (user *Userinfo, host string, err error) {
577 i := strings.LastIndex(authority, "@")
578 if i < 0 {
579 host, err = parseHost(authority)
580 } else {
581 host, err = parseHost(authority[i+1:])
582 }
583 if err != nil {
584 return nil, "", err
585 }
586 if i < 0 {
587 return nil, host, nil
588 }
589 userinfo := authority[:i]
590 if !validUserinfo(userinfo) {
591 return nil, "", errors.New("net/url: invalid userinfo")
592 }
593 if !strings.Contains(userinfo, ":") {
594 if userinfo, err = unescape(userinfo, encodeUserPassword); err != nil {
595 return nil, "", err
596 }
597 user = User(userinfo)
598 } else {
599 username, password, _ := strings.Cut(userinfo, ":")
600 if username, err = unescape(username, encodeUserPassword); err != nil {
601 return nil, "", err
602 }
603 if password, err = unescape(password, encodeUserPassword); err != nil {
604 return nil, "", err
605 }
606 user = UserPassword(username, password)
607 }
608 return user, host, nil
609 }
610
611
612
613 func parseHost(host string) (string, error) {
614 if strings.HasPrefix(host, "[") {
615
616
617 i := strings.LastIndex(host, "]")
618 if i < 0 {
619 return "", errors.New("missing ']' in host")
620 }
621 colonPort := host[i+1:]
622 if !validOptionalPort(colonPort) {
623 return "", fmt.Errorf("invalid port %q after host", colonPort)
624 }
625
626
627
628
629
630
631
632 zone := strings.Index(host[:i], "%25")
633 if zone >= 0 {
634 host1, err := unescape(host[:zone], encodeHost)
635 if err != nil {
636 return "", err
637 }
638 host2, err := unescape(host[zone:i], encodeZone)
639 if err != nil {
640 return "", err
641 }
642 host3, err := unescape(host[i:], encodeHost)
643 if err != nil {
644 return "", err
645 }
646 return host1 + host2 + host3, nil
647 }
648 } else if i := strings.LastIndex(host, ":"); i != -1 {
649 colonPort := host[i:]
650 if !validOptionalPort(colonPort) {
651 return "", fmt.Errorf("invalid port %q after host", colonPort)
652 }
653 }
654
655 var err error
656 if host, err = unescape(host, encodeHost); err != nil {
657 return "", err
658 }
659 return host, nil
660 }
661
662
663
664
665
666
667
668
669
670 func (u *URL) setPath(p string) error {
671 path, err := unescape(p, encodePath)
672 if err != nil {
673 return err
674 }
675 u.Path = path
676 if escp := escape(path, encodePath); p == escp {
677
678 u.RawPath = ""
679 } else {
680 u.RawPath = p
681 }
682 return nil
683 }
684
685
686
687
688
689
690
691
692
693
694 func (u *URL) EscapedPath() string {
695 if u.RawPath != "" && validEncoded(u.RawPath, encodePath) {
696 p, err := unescape(u.RawPath, encodePath)
697 if err == nil && p == u.Path {
698 return u.RawPath
699 }
700 }
701 if u.Path == "*" {
702 return "*"
703 }
704 return escape(u.Path, encodePath)
705 }
706
707
708
709
710 func validEncoded(s string, mode encoding) bool {
711 for i := 0; i < len(s); i++ {
712
713
714
715
716
717 switch s[i] {
718 case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '@':
719
720 case '[', ']':
721
722 case '%':
723
724 default:
725 if shouldEscape(s[i], mode) {
726 return false
727 }
728 }
729 }
730 return true
731 }
732
733
734 func (u *URL) setFragment(f string) error {
735 frag, err := unescape(f, encodeFragment)
736 if err != nil {
737 return err
738 }
739 u.Fragment = frag
740 if escf := escape(frag, encodeFragment); f == escf {
741
742 u.RawFragment = ""
743 } else {
744 u.RawFragment = f
745 }
746 return nil
747 }
748
749
750
751
752
753
754
755
756
757 func (u *URL) EscapedFragment() string {
758 if u.RawFragment != "" && validEncoded(u.RawFragment, encodeFragment) {
759 f, err := unescape(u.RawFragment, encodeFragment)
760 if err == nil && f == u.Fragment {
761 return u.RawFragment
762 }
763 }
764 return escape(u.Fragment, encodeFragment)
765 }
766
767
768
769 func validOptionalPort(port string) bool {
770 if port == "" {
771 return true
772 }
773 if port[0] != ':' {
774 return false
775 }
776 for _, b := range port[1:] {
777 if b < '0' || b > '9' {
778 return false
779 }
780 }
781 return true
782 }
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805 func (u *URL) String() string {
806 var buf strings.Builder
807 if u.Scheme != "" {
808 buf.WriteString(u.Scheme)
809 buf.WriteByte(':')
810 }
811 if u.Opaque != "" {
812 buf.WriteString(u.Opaque)
813 } else {
814 if u.Scheme != "" || u.Host != "" || u.User != nil {
815 if u.OmitHost && u.Host == "" && u.User == nil {
816
817 } else {
818 if u.Host != "" || u.Path != "" || u.User != nil {
819 buf.WriteString("//")
820 }
821 if ui := u.User; ui != nil {
822 buf.WriteString(ui.String())
823 buf.WriteByte('@')
824 }
825 if h := u.Host; h != "" {
826 buf.WriteString(escape(h, encodeHost))
827 }
828 }
829 }
830 path := u.EscapedPath()
831 if path != "" && path[0] != '/' && u.Host != "" {
832 buf.WriteByte('/')
833 }
834 if buf.Len() == 0 {
835
836
837
838
839
840
841 if segment, _, _ := strings.Cut(path, "/"); strings.Contains(segment, ":") {
842 buf.WriteString("./")
843 }
844 }
845 buf.WriteString(path)
846 }
847 if u.ForceQuery || u.RawQuery != "" {
848 buf.WriteByte('?')
849 buf.WriteString(u.RawQuery)
850 }
851 if u.Fragment != "" {
852 buf.WriteByte('#')
853 buf.WriteString(u.EscapedFragment())
854 }
855 return buf.String()
856 }
857
858
859
860 func (u *URL) Redacted() string {
861 if u == nil {
862 return ""
863 }
864
865 ru := *u
866 if _, has := ru.User.Password(); has {
867 ru.User = UserPassword(ru.User.Username(), "xxxxx")
868 }
869 return ru.String()
870 }
871
872
873
874
875
876 type Values map[string][]string
877
878
879
880
881
882 func (v Values) Get(key string) string {
883 if v == nil {
884 return ""
885 }
886 vs := v[key]
887 if len(vs) == 0 {
888 return ""
889 }
890 return vs[0]
891 }
892
893
894
895 func (v Values) Set(key, value string) {
896 v[key] = []string{value}
897 }
898
899
900
901 func (v Values) Add(key, value string) {
902 v[key] = append(v[key], value)
903 }
904
905
906 func (v Values) Del(key string) {
907 delete(v, key)
908 }
909
910
911 func (v Values) Has(key string) bool {
912 _, ok := v[key]
913 return ok
914 }
915
916
917
918
919
920
921
922
923
924
925
926 func ParseQuery(query string) (Values, error) {
927 m := make(Values)
928 err := parseQuery(m, query)
929 return m, err
930 }
931
932 func parseQuery(m Values, query string) (err error) {
933 for query != "" {
934 var key string
935 key, query, _ = strings.Cut(query, "&")
936 if strings.Contains(key, ";") {
937 err = fmt.Errorf("invalid semicolon separator in query")
938 continue
939 }
940 if key == "" {
941 continue
942 }
943 key, value, _ := strings.Cut(key, "=")
944 key, err1 := QueryUnescape(key)
945 if err1 != nil {
946 if err == nil {
947 err = err1
948 }
949 continue
950 }
951 value, err1 = QueryUnescape(value)
952 if err1 != nil {
953 if err == nil {
954 err = err1
955 }
956 continue
957 }
958 m[key] = append(m[key], value)
959 }
960 return err
961 }
962
963
964
965 func (v Values) Encode() string {
966 if v == nil {
967 return ""
968 }
969 var buf strings.Builder
970 keys := make([]string, 0, len(v))
971 for k := range v {
972 keys = append(keys, k)
973 }
974 sort.Strings(keys)
975 for _, k := range keys {
976 vs := v[k]
977 keyEscaped := QueryEscape(k)
978 for _, v := range vs {
979 if buf.Len() > 0 {
980 buf.WriteByte('&')
981 }
982 buf.WriteString(keyEscaped)
983 buf.WriteByte('=')
984 buf.WriteString(QueryEscape(v))
985 }
986 }
987 return buf.String()
988 }
989
990
991
992 func resolvePath(base, ref string) string {
993 var full string
994 if ref == "" {
995 full = base
996 } else if ref[0] != '/' {
997 i := strings.LastIndex(base, "/")
998 full = base[:i+1] + ref
999 } else {
1000 full = ref
1001 }
1002 if full == "" {
1003 return ""
1004 }
1005
1006 var (
1007 elem string
1008 dst strings.Builder
1009 )
1010 first := true
1011 remaining := full
1012
1013 dst.WriteByte('/')
1014 found := true
1015 for found {
1016 elem, remaining, found = strings.Cut(remaining, "/")
1017 if elem == "." {
1018 first = false
1019
1020 continue
1021 }
1022
1023 if elem == ".." {
1024
1025 str := dst.String()[1:]
1026 index := strings.LastIndexByte(str, '/')
1027
1028 dst.Reset()
1029 dst.WriteByte('/')
1030 if index == -1 {
1031 first = true
1032 } else {
1033 dst.WriteString(str[:index])
1034 }
1035 } else {
1036 if !first {
1037 dst.WriteByte('/')
1038 }
1039 dst.WriteString(elem)
1040 first = false
1041 }
1042 }
1043
1044 if elem == "." || elem == ".." {
1045 dst.WriteByte('/')
1046 }
1047
1048
1049 r := dst.String()
1050 if len(r) > 1 && r[1] == '/' {
1051 r = r[1:]
1052 }
1053 return r
1054 }
1055
1056
1057
1058 func (u *URL) IsAbs() bool {
1059 return u.Scheme != ""
1060 }
1061
1062
1063
1064
1065 func (u *URL) Parse(ref string) (*URL, error) {
1066 refURL, err := Parse(ref)
1067 if err != nil {
1068 return nil, err
1069 }
1070 return u.ResolveReference(refURL), nil
1071 }
1072
1073
1074
1075
1076
1077
1078
1079 func (u *URL) ResolveReference(ref *URL) *URL {
1080 url := *ref
1081 if ref.Scheme == "" {
1082 url.Scheme = u.Scheme
1083 }
1084 if ref.Scheme != "" || ref.Host != "" || ref.User != nil {
1085
1086
1087
1088 url.setPath(resolvePath(ref.EscapedPath(), ""))
1089 return &url
1090 }
1091 if ref.Opaque != "" {
1092 url.User = nil
1093 url.Host = ""
1094 url.Path = ""
1095 return &url
1096 }
1097 if ref.Path == "" && !ref.ForceQuery && ref.RawQuery == "" {
1098 url.RawQuery = u.RawQuery
1099 if ref.Fragment == "" {
1100 url.Fragment = u.Fragment
1101 url.RawFragment = u.RawFragment
1102 }
1103 }
1104
1105 url.Host = u.Host
1106 url.User = u.User
1107 url.setPath(resolvePath(u.EscapedPath(), ref.EscapedPath()))
1108 return &url
1109 }
1110
1111
1112
1113
1114 func (u *URL) Query() Values {
1115 v, _ := ParseQuery(u.RawQuery)
1116 return v
1117 }
1118
1119
1120
1121 func (u *URL) RequestURI() string {
1122 result := u.Opaque
1123 if result == "" {
1124 result = u.EscapedPath()
1125 if result == "" {
1126 result = "/"
1127 }
1128 } else {
1129 if strings.HasPrefix(result, "//") {
1130 result = u.Scheme + ":" + result
1131 }
1132 }
1133 if u.ForceQuery || u.RawQuery != "" {
1134 result += "?" + u.RawQuery
1135 }
1136 return result
1137 }
1138
1139
1140
1141
1142
1143 func (u *URL) Hostname() string {
1144 host, _ := splitHostPort(u.Host)
1145 return host
1146 }
1147
1148
1149
1150
1151 func (u *URL) Port() string {
1152 _, port := splitHostPort(u.Host)
1153 return port
1154 }
1155
1156
1157
1158
1159 func splitHostPort(hostPort string) (host, port string) {
1160 host = hostPort
1161
1162 colon := strings.LastIndexByte(host, ':')
1163 if colon != -1 && validOptionalPort(host[colon:]) {
1164 host, port = host[:colon], host[colon+1:]
1165 }
1166
1167 if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
1168 host = host[1 : len(host)-1]
1169 }
1170
1171 return
1172 }
1173
1174
1175
1176
1177 func (u *URL) MarshalBinary() (text []byte, err error) {
1178 return []byte(u.String()), nil
1179 }
1180
1181 func (u *URL) UnmarshalBinary(text []byte) error {
1182 u1, err := Parse(string(text))
1183 if err != nil {
1184 return err
1185 }
1186 *u = *u1
1187 return nil
1188 }
1189
1190
1191
1192
1193 func (u *URL) JoinPath(elem ...string) *URL {
1194 elem = append([]string{u.EscapedPath()}, elem...)
1195 var p string
1196 if !strings.HasPrefix(elem[0], "/") {
1197
1198
1199 elem[0] = "/" + elem[0]
1200 p = path.Join(elem...)[1:]
1201 } else {
1202 p = path.Join(elem...)
1203 }
1204
1205
1206 if strings.HasSuffix(elem[len(elem)-1], "/") && !strings.HasSuffix(p, "/") {
1207 p += "/"
1208 }
1209 url := *u
1210 url.setPath(p)
1211 return &url
1212 }
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223 func validUserinfo(s string) bool {
1224 for _, r := range s {
1225 if 'A' <= r && r <= 'Z' {
1226 continue
1227 }
1228 if 'a' <= r && r <= 'z' {
1229 continue
1230 }
1231 if '0' <= r && r <= '9' {
1232 continue
1233 }
1234 switch r {
1235 case '-', '.', '_', ':', '~', '!', '$', '&', '\'',
1236 '(', ')', '*', '+', ',', ';', '=', '%', '@':
1237 continue
1238 default:
1239 return false
1240 }
1241 }
1242 return true
1243 }
1244
1245
1246 func stringContainsCTLByte(s string) bool {
1247 for i := 0; i < len(s); i++ {
1248 b := s[i]
1249 if b < ' ' || b == 0x7f {
1250 return true
1251 }
1252 }
1253 return false
1254 }
1255
1256
1257
1258 func JoinPath(base string, elem ...string) (result string, err error) {
1259 url, err := Parse(base)
1260 if err != nil {
1261 return
1262 }
1263 result = url.JoinPath(elem...).String()
1264 return
1265 }
1266
View as plain text