| /* |
| * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include <setjmp.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "jni.h" |
| #include "jvm.h" |
| |
| typedef unsigned short unicode; |
| |
| static char * |
| skip_over_fieldname(char *name, jboolean slash_okay, |
| unsigned int len); |
| static char * |
| skip_over_field_signature(char *name, jboolean void_okay, |
| unsigned int len); |
| |
| /* |
| * Return non-zero if the character is a valid in JVM class name, zero |
| * otherwise. The only characters currently disallowed from JVM class |
| * names are given in the table below: |
| * |
| * Character Hex Decimal |
| * '.' 0x2e 46 |
| * '/' 0x2f 47 |
| * ';' 0x3b 59 |
| * '[' 0x5b 91 |
| * |
| * (Method names have further restrictions dealing with the '<' and |
| * '>' characters.) |
| */ |
| static int isJvmIdentifier(unicode ch) { |
| if( ch > 91 || ch < 46 ) |
| return 1; /* Lowercase ASCII letters are > 91 */ |
| else { /* 46 <= ch <= 91 */ |
| if (ch <= 90 && ch >= 60) { |
| return 1; /* Uppercase ASCII recognized here */ |
| } else { /* ch == 91 || 46 <= ch <= 59 */ |
| if (ch == 91 || ch == 59 || ch <= 47) |
| return 0; |
| else |
| return 1; |
| } |
| } |
| } |
| |
| static unicode |
| next_utf2unicode(char **utfstring_ptr, int * valid) |
| { |
| unsigned char *ptr = (unsigned char *)(*utfstring_ptr); |
| unsigned char ch, ch2, ch3; |
| int length = 1; /* default length */ |
| unicode result = 0x80; /* default bad result; */ |
| *valid = 1; |
| switch ((ch = ptr[0]) >> 4) { |
| default: |
| result = ch; |
| break; |
| |
| case 0x8: case 0x9: case 0xA: case 0xB: case 0xF: |
| /* Shouldn't happen. */ |
| *valid = 0; |
| break; |
| |
| case 0xC: case 0xD: |
| /* 110xxxxx 10xxxxxx */ |
| if (((ch2 = ptr[1]) & 0xC0) == 0x80) { |
| unsigned char high_five = ch & 0x1F; |
| unsigned char low_six = ch2 & 0x3F; |
| result = (high_five << 6) + low_six; |
| length = 2; |
| } |
| break; |
| |
| case 0xE: |
| /* 1110xxxx 10xxxxxx 10xxxxxx */ |
| if (((ch2 = ptr[1]) & 0xC0) == 0x80) { |
| if (((ch3 = ptr[2]) & 0xC0) == 0x80) { |
| unsigned char high_four = ch & 0x0f; |
| unsigned char mid_six = ch2 & 0x3f; |
| unsigned char low_six = ch3 & 0x3f; |
| result = (((high_four << 6) + mid_six) << 6) + low_six; |
| length = 3; |
| } else { |
| length = 2; |
| } |
| } |
| break; |
| } /* end of switch */ |
| |
| *utfstring_ptr = (char *)(ptr + length); |
| return result; |
| } |
| |
| /* Take pointer to a string. Skip over the longest part of the string that |
| * could be taken as a fieldname. Allow '/' if slash_okay is JNI_TRUE. |
| * |
| * Return a pointer to just past the fieldname. Return NULL if no fieldname |
| * at all was found, or in the case of slash_okay being true, we saw |
| * consecutive slashes (meaning we were looking for a qualified path but |
| * found something that was badly-formed). |
| */ |
| static char * |
| skip_over_fieldname(char *name, jboolean slash_okay, |
| unsigned int length) |
| { |
| char *p; |
| unicode ch; |
| unicode last_ch = 0; |
| int valid = 1; |
| /* last_ch == 0 implies we are looking at the first char. */ |
| for (p = name; p != name + length; last_ch = ch) { |
| char *old_p = p; |
| ch = *p; |
| if (ch < 128) { |
| p++; |
| if (isJvmIdentifier(ch)) { |
| continue; |
| } |
| } else { |
| char *tmp_p = p; |
| ch = next_utf2unicode(&tmp_p, &valid); |
| if (valid == 0) |
| return 0; |
| p = tmp_p; |
| if (isJvmIdentifier(ch)) { |
| continue; |
| } |
| } |
| |
| if (slash_okay && ch == '/' && last_ch) { |
| if (last_ch == '/') { |
| return 0; /* Don't permit consecutive slashes */ |
| } |
| } else if (ch == '_' || ch == '$') { |
| } else { |
| return last_ch ? old_p : 0; |
| } |
| } |
| return last_ch ? p : 0; |
| } |
| |
| /* Take pointer to a string. Skip over the longest part of the string that |
| * could be taken as a field signature. Allow "void" if void_okay. |
| * |
| * Return a pointer to just past the signature. Return NULL if no legal |
| * signature is found. |
| */ |
| |
| static char * |
| skip_over_field_signature(char *name, jboolean void_okay, |
| unsigned int length) |
| { |
| unsigned int array_dim = 0; |
| for (;length > 0;) { |
| switch (name[0]) { |
| case JVM_SIGNATURE_VOID: |
| if (!void_okay) return 0; |
| /* FALL THROUGH */ |
| case JVM_SIGNATURE_BOOLEAN: |
| case JVM_SIGNATURE_BYTE: |
| case JVM_SIGNATURE_CHAR: |
| case JVM_SIGNATURE_SHORT: |
| case JVM_SIGNATURE_INT: |
| case JVM_SIGNATURE_FLOAT: |
| case JVM_SIGNATURE_LONG: |
| case JVM_SIGNATURE_DOUBLE: |
| return name + 1; |
| |
| case JVM_SIGNATURE_CLASS: { |
| /* Skip over the classname, if one is there. */ |
| char *p = |
| skip_over_fieldname(name + 1, JNI_TRUE, --length); |
| /* The next character better be a semicolon. */ |
| if (p && p - name - 1 > 0 && p[0] == ';') |
| return p + 1; |
| return 0; |
| } |
| |
| case JVM_SIGNATURE_ARRAY: |
| array_dim++; |
| /* JVMS 2nd ed. 4.10 */ |
| /* The number of dimensions in an array is limited to 255 ... */ |
| if (array_dim > 255) { |
| return 0; |
| } |
| /* The rest of what's there better be a legal signature. */ |
| name++; |
| length--; |
| void_okay = JNI_FALSE; |
| break; |
| |
| default: |
| return 0; |
| } |
| } |
| return 0; |
| } |
| |
| |
| /* Used in java/lang/Class.c */ |
| /* Determine if the specified name is legal |
| * UTF name for a classname. |
| * |
| * Note that this routine expects the internal form of qualified classes: |
| * the dots should have been replaced by slashes. |
| */ |
| JNIEXPORT jboolean |
| VerifyClassname(char *name, jboolean allowArrayClass) |
| { |
| unsigned int length = strlen(name); |
| char *p; |
| |
| if (length > 0 && name[0] == JVM_SIGNATURE_ARRAY) { |
| if (!allowArrayClass) { |
| return JNI_FALSE; |
| } else { |
| /* Everything that's left better be a field signature */ |
| p = skip_over_field_signature(name, JNI_FALSE, length); |
| } |
| } else { |
| /* skip over the fieldname. Slashes are okay */ |
| p = skip_over_fieldname(name, JNI_TRUE, length); |
| } |
| return (p != 0 && p - name == (ptrdiff_t)length); |
| } |
| |
| /* |
| * Translates '.' to '/'. Returns JNI_TRUE is any / were present. |
| */ |
| JNIEXPORT jboolean |
| VerifyFixClassname(char *name) |
| { |
| char *p = name; |
| jboolean slashesFound = JNI_FALSE; |
| int valid = 1; |
| |
| while (valid != 0 && *p != '\0') { |
| if (*p == '/') { |
| slashesFound = JNI_TRUE; |
| p++; |
| } else if (*p == '.') { |
| *p++ = '/'; |
| } else { |
| next_utf2unicode(&p, &valid); |
| } |
| } |
| |
| return slashesFound && valid != 0; |
| } |
