Index: Python/import.c
===================================================================
--- Python/import.c	(revision 62297)
+++ Python/import.c	(working copy)
@@ -2131,13 +2131,15 @@
 
 	if ((pkgname != NULL) && (pkgname != Py_None)) {
 		/* __package__ is set, so use it */
+		char *pkgname_str;
 		Py_ssize_t len;
+
 		if (!PyUnicode_Check(pkgname)) {
 			PyErr_SetString(PyExc_ValueError,
 					"__package__ set to non-string");
 			return NULL;
 		}
-		len = PyUnicode_GET_SIZE(pkgname);
+		pkgname_str = PyUnicode_AsStringAndSize(pkgname, &len);
 		if (len == 0) {
 			if (level > 0) {
 				PyErr_SetString(PyExc_ValueError,
@@ -2151,7 +2153,7 @@
 					"Package name too long");
 			return NULL;
 		}
-		strcpy(buf, PyUnicode_AsString(pkgname));
+		strcpy(buf, pkgname_str);
 	} else {
 		/* __package__ not set, so figure it out and set it */
 		modname = PyDict_GetItem(globals, namestr);
@@ -2161,14 +2163,17 @@
 		modpath = PyDict_GetItem(globals, pathstr);
 		if (modpath != NULL) {
 			/* __path__ is set, so modname is already the package name */
-			Py_ssize_t len = PyUnicode_GET_SIZE(modname);
+			char *modname_str;
+			Py_ssize_t len;
 			int error;
+
+			modname_str = PyUnicode_AsStringAndSize(modname, &len);
 			if (len > MAXPATHLEN) {
 				PyErr_SetString(PyExc_ValueError,
 						"Module name too long");
 				return NULL;
 			}
-			strcpy(buf, PyUnicode_AsString(modname));
+			strcpy(buf, modname_str);
 			error = PyDict_SetItem(globals, pkgstr, modname);
 			if (error) {
 				PyErr_SetString(PyExc_ValueError,
@@ -2195,7 +2200,7 @@
 				}
 				return Py_None;
 			}
-			len = lastdot - start;
+			len = (size_t)(lastdot - start);
 			if (len >= MAXPATHLEN) {
 				PyErr_SetString(PyExc_ValueError,
 						"Module name too long");
Index: Python/structmember.c
===================================================================
--- Python/structmember.c	(revision 62297)
+++ Python/structmember.c	(working copy)
@@ -239,15 +239,22 @@
 		*(PyObject **)addr = v;
 		Py_XDECREF(oldv);
 		break;
-	case T_CHAR:
-		if (PyUnicode_Check(v) && PyUnicode_GetSize(v) == 1) {
-			*(char*)addr = PyUnicode_AsString(v)[0];
+	case T_CHAR: {
+		char *string;
+		Py_ssize_t len;
+
+		if (!PyUnicode_Check(v)) {
+			PyErr_BadArgument();
+			return -1;
 		}
-		else {
+		string = PyUnicode_AsStringAndSize(v, &len);
+		if (len != 1) {
 			PyErr_BadArgument();
 			return -1;
 		}
+		*(char*)addr = string[0];
 		break;
+		}
 #ifdef HAVE_LONG_LONG
 	case T_LONGLONG:{
 		PY_LONG_LONG value;
Index: Objects/typeobject.c
===================================================================
--- Objects/typeobject.c	(revision 62297)
+++ Objects/typeobject.c	(working copy)
@@ -1255,7 +1255,7 @@
 			if (PyList_GET_ITEM(list, j) == o) {
 				o = class_name(o);
 				PyErr_Format(PyExc_TypeError,
-					     "duplicate base class %s",
+					     "duplicate base class %.400s",
 					     o ? PyUnicode_AsString(o) : "?");
 				Py_XDECREF(o);
 				return -1;
@@ -2133,20 +2133,28 @@
 	{
 		PyObject *doc = PyDict_GetItemString(dict, "__doc__");
 		if (doc != NULL && PyUnicode_Check(doc)) {
-			size_t n;
+			Py_ssize_t len;
+			char *doc_str;
 			char *tp_doc;
-			const char *str = PyUnicode_AsString(doc);
-			if (str == NULL) {
+
+			doc_str = PyUnicode_AsStringAndSize(doc, &len);
+			if (doc_str == NULL) {
 				Py_DECREF(type);
 				return NULL;
 			}
-			n = strlen(str);
-			tp_doc = (char *)PyObject_MALLOC(n+1);
+			if ((Py_ssize_t)strlen(doc_str) != len) {
+				PyErr_SetString(PyExc_TypeError,
+						"__doc__ contains null-bytes");
+				Py_DECREF(type);
+				return NULL;
+			}
+			tp_doc = (char *)PyObject_MALLOC(len + 1);
 			if (tp_doc == NULL) {
 				Py_DECREF(type);
 				return NULL;
 			}
-			memcpy(tp_doc, str, n+1);
+			memcpy(tp_doc, doc_str, len);
+			tp_doc[len] = '\0';
 			type->tp_doc = tp_doc;
 		}
 	}
Index: Modules/datetimemodule.c
===================================================================
--- Modules/datetimemodule.c	(revision 62297)
+++ Modules/datetimemodule.c	(working copy)
@@ -1217,10 +1217,9 @@
 	assert(object && format && timetuple);
 	assert(PyUnicode_Check(format));
 	/* Convert the input format to a C string and size */
-	pin = PyUnicode_AsString(format);
+	pin = PyUnicode_AsStringAndSize(format, &flen);
 	if (!pin)
 		return NULL;
-	flen = PyUnicode_GetSize(format);
 
 	/* Give up if the year is before 1900.
 	 * Python strftime() plays games with the year, and different
Index: Modules/zipimport.c
===================================================================
--- Modules/zipimport.c	(revision 62297)
+++ Modules/zipimport.c	(working copy)
@@ -61,16 +61,14 @@
 zipimporter_init(ZipImporter *self, PyObject *args, PyObject *kwds)
 {
 	char *path, *p, *prefix, buf[MAXPATHLEN+2];
-	size_t len;
+	Py_ssize_t len;
 
 	if (!_PyArg_NoKeywords("zipimporter()", kwds))
 		return -1;
 
-	if (!PyArg_ParseTuple(args, "s:zipimporter",
-			      &path))
+	if (!PyArg_ParseTuple(args, "s#:zipimporter", &path, &len))
 		return -1;
 
-	len = strlen(path);
 	if (len == 0) {
 		PyErr_SetString(ZipImportError, "archive path is empty");
 		return -1;
@@ -329,7 +327,7 @@
 		fullpath = PyUnicode_FromFormat("%s%c%s%s",
 					PyUnicode_AsString(self->archive),
 					SEP,
-					*prefix ? prefix : "",
+					prefix ? prefix : "",
 					subname);
 		if (fullpath == NULL)
 			goto error;
@@ -388,6 +386,7 @@
 #endif
 	PyObject *toc_entry;
 	Py_ssize_t len;
+	char *archive_str;
 
 	if (!PyArg_ParseTuple(args, "s:zipimporter.get_data", &path))
 		return NULL;
@@ -404,9 +403,9 @@
 	}
 	path = buf;
 #endif
-	len = PyUnicode_GET_SIZE(self->archive);
+	archive_str = PyUnicode_AsStringAndSize(self->archive, &len);
 	if ((size_t)len < strlen(path) &&
-	    strncmp(path, PyUnicode_AsString(self->archive), len) == 0 &&
+	    strncmp(path, archive_str, len) == 0 &&
 	    path[len] == SEP) {
 		path = path + len + 1;
 	}
@@ -416,7 +415,7 @@
 		PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
 		return NULL;
 	}
-	return get_data(PyUnicode_AsString(self->archive), toc_entry);
+	return get_data(archive_str, toc_entry);
 }
 
 static PyObject *
Index: Modules/parsermodule.c
===================================================================
--- Modules/parsermodule.c	(revision 62297)
+++ Modules/parsermodule.c	(working copy)
@@ -717,11 +717,11 @@
                     Py_DECREF(o);
                 }
             }
-            temp_str = PyUnicode_AsString(temp);
-            len = PyUnicode_GET_SIZE(temp) + 1;
-            strn = (char *)PyObject_MALLOC(len);
+            temp_str = PyUnicode_AsStringAndSize(temp, &len);
+            strn = (char *)PyObject_MALLOC(len + 1);
             if (strn != NULL)
                 (void) memcpy(strn, temp_str, len);
+            strn[len] = '\0';
             Py_DECREF(temp);
         }
         else if (!ISNONTERMINAL(type)) {
@@ -807,11 +807,11 @@
             if (res && encoding) {
                 Py_ssize_t len;
                 const char *temp;
-                temp = PyUnicode_AsString(encoding);
-                len = PyUnicode_GET_SIZE(encoding) + 1;
-                res->n_str = (char *)PyObject_MALLOC(len);
+                temp = PyUnicode_AsStringAndSize(encoding, &len);
+                res->n_str = (char *)PyObject_MALLOC(len + 1);
                 if (res->n_str != NULL && temp != NULL)
                     (void) memcpy(res->n_str, temp, len);
+                res->n_str[len] = '\0';
                 Py_DECREF(encoding);
                 Py_DECREF(tuple);
             }